מבני נתונים ואלגוריתמים מובילים ב- Java שעליך לדעת

בלוג זה בנושא מבני נתונים ואלגוריתמים בג'אווה יעזור לכם להבין את כל מבני הנתונים והאלגוריתמים העיקריים בג'אווה.

אם הייתי צריך לבחור את הנושא החשוב ביותר בפיתוח תוכנה, זה יהיה מבני נתונים ואלגוריתמים. אתה יכול לחשוב על זה ככלי הבסיסי העומד לרשות כל מתכנת מחשבים. במהלך התכנות, אנו משתמשים מבני מידע לאחסן ולארגן נתונים, ו אלגוריתמים לתפעל את הנתונים במבנים אלה. מאמר זה מכיל סקירה מפורטת של כל מבני הנתונים והאלגוריתמים הנפוצים ב כדי לאפשר לקוראים להצטייד היטב.



להלן הנושאים הנדונים במאמר זה:



מבני נתונים בג'אווה

מבנה נתונים הוא דרך לאחסן ולארגן נתונים במחשב כך שניתן יהיה להשתמש בהם ביעילות. הוא מספק אמצעי לניהול כמויות גדולות של נתונים ביעילות. ומבני נתונים יעילים הם המפתח לעיצוב אלגוריתמים יעילים.

בבמאמר זה 'מבני נתונים ואלגוריתמים בג'אווה', אנו הולכים לכסות מבני נתונים בסיסיים כגון:



בואו נבדוק כל אחד מהם.

מבני נתונים ליניאריים בג'אווה

מבני נתונים ליניאריים ב הם אלה שהאלמנטים שלהם רצופים ומסודרים באופן כך: יש רק אחד אלמנט ראשון ויש לו רק אחד האלמנט הבא , יש רק אחד אלמנט אחרון ויש לו רק אחד אלמנט קודם , בעוד שלכל האלמנטים האחרים יש הַבָּא ו קודם אֵלֵמֶנט.

מערכים

An מַעֲרָך הוא מבנה נתונים ליניאריהמייצג קבוצה של אלמנטים דומים, אליהם ניתן לגשת באמצעות אינדקס. יש לספק גודל של מערך לפני שמירת נתונים. להלן מאפיינים של מערך:



  • כל אלמנט במערך הוא מאותו סוג נתונים ויש לו אותו גודל
  • אלמנטים של המערך מאוחסנים במיקומי זיכרון רצופים כאשר האלמנט הראשון מתחיל במיקום הזיכרון הקטן ביותר
  • ניתן לגשת באופן אקראי לאלמנטים של המערך
  • מבנה נתוני המערך אינו דינמי לחלוטין

מערכים - אדוריקה

לדוגמה , אולי נרצה במשחק וידיאו כדי לעקוב אחר עשרת התוצאות הראשונות של אותו משחק. במקום להשתמש בעשרה שונים משתנים למשימה זו נוכל להשתמש בשם יחיד לכל הקבוצה ולהשתמש במספרי אינדקס בכדי להתייחס לציונים הגבוהים באותה קבוצה.

רשימה מקושרת

ל הוא מבנה נתונים ליניארי עם אוסף של מספר צמתים, כאשר eאלמנט ach מאחסן נתונים משלו ומצביע למיקום האלמנט הבא. החוליה האחרונה ברשימה מקושרת מצביעה על null, המציין את סוף השרשרת. אלמנט ברשימה מקושרת נקרא a צוֹמֶת . הצומת הראשון נקרא רֹאשׁ .הצומת האחרון נקראה זָנָב .

סוגי הרשימה המקושרת

רשימה מקושרת יחידה (חד כיוונית)

רשימת קישורים כפולה (דו כיוונית)

רשימה מקושרת מעגלית

מהי מפתחות מפתח בפייתון

הנה דוגמה פשוטה: דמיין רשימה מקושרת כמו שרשרת אטבים המקושרים זה לזה. ניתן להוסיף בקלות מהדק נוסף למעלה או לתחתית. זה אפילו מהיר להכניס אחד באמצע. כל שעליך לעשות הוא פשוט לנתק את השרשרת באמצע, להוסיף את המהדק החדש ואז לחבר מחדש את החצי השני. רשימה מקושרת דומה.

ערימות

לַעֲרוֹם, מבנה נתונים מופשט, הוא אוסף של חפצים שמוכנסים ומוסרים על פי אחרון בהתחלה (LIFO) עִקָרוֹן. ניתן להכניס אובייקטים לערימה בכל נקודת זמן, אך רק האובייקט שהוכנס לאחרונה (כלומר 'האחרון') ניתן להסיר בכל עת.להלן מאפיינים של ערימה:

  • זוהי רשימה מסודרת שבההכנסה ומחיקה יכולה להתבצע רק בקצה אחד שנקרא חלק עליון
  • מבנה נתונים רקורסיבי עם מצביע לאלמנט העליון שלו
  • עוקב אחר אחרון בהתחלה (LIFO) עִקָרוֹן
  • תומך בשתי שיטות בסיסיות ביותר
    • דחיפה (e): הכנס את האלמנט e, לראש הערימה
    • pop (): הסר והחזיר את האלמנט העליון בערימה

דוגמאות מעשיות לערימה כוללות כאשר הופכים מילה,כדי לבדוק את נכונות סוגרייםסדר פעולות,יישום פונקציונליות חזרה בדפדפנים ורבים אחרים.

תורים

הם גם סוג אחר של מבנה נתונים מופשט. שלא כמו ערימה, התור הוא אוסף של אובייקטים שמוכנסים ומוסרים בהתאם ל- ראשית בהתחלה (FIFO) עִקָרוֹן. כלומר, ניתן להכניס אלמנטים בכל נקודת זמן, אך רק את האלמנט שהיה בתור הכי הרבה זמן ניתן להסיר בכל עת.להלן רשימת המאפיינים של תור:

  • מכונה לעתים קרובות ה- ראשון בהתחלה רשימה
  • תומך בשתי שיטות בסיסיות ביותר
    • enqueue (e): הכנס אלמנט e, ב חלק אחורי של התור
    • dequeue (): הסר והחזיר את האלמנט מה- חֲזִית של התור

נעשה שימוש בתוריםהעברה נתונים אסינכרונית בין שני תהליכים, תזמון מעבד, תזמון דיסקים ומצבים אחרים שבהם משאבים משותפים בין מספר משתמשים ומוגשים על בסיס שרת כל הקודם זוכה. בהמשך במאמר זה 'מבני נתונים ואלגוריתמים בג'אווה', יש לנו מבני נתונים היררכיים.

מבני נתונים היררכיים בג'אווה

עץ בינארי

עץ בינארי הואמבני נתוני עץ היררכיים בהם לכל צומת לכל היותר שני ילדים , המכונים ילד עזב וה ילד נכון . לכל עץ בינארי יש את קבוצות הצמתים הבאות:

  • צומת שורש: זהו הצומת העליון ביותר המכונה לעתים קרובות הצומת הראשימכיוון שניתן להגיע לכל שאר הצמתים מהשורש
  • עץ תת-שמאלי, שהוא גם עץ בינארי
  • Sub-Tree ימני, שהוא גם עץ בינארי

להלן רשימת המאפיינים של עץ בינארי:

  • ניתן לעבור על עץ בינארי בשתי דרכים:
    • עומק חצייה ראשונה : לפי סדר (שמאל-שורש-ימין), הזמנה מראש (שורש-שמאל-ימין) והזמנה חוזרת (שמאל-ימין-שורש)
    • מעבר ראשון רוחב : מעבר סדר ברמה
  • מורכבות הזמן של מעבר עצים: O (n)
  • המספר המרבי של הצמתים ברמה 'l' = 2l-1.

היישומים של עצים בינאריים כוללים:

  • משמש ביישומי חיפוש רבים שבהם נתונים נכנסים / יוצאים כל הזמן
  • כזרימת עבודה להרכבת תמונות דיגיטליות לאפקטים חזותיים
  • משמש כמעט בכל נתב ברוחב פס גבוה לאחסון שולחנות נתב
  • משמש גם ברשת אלחוטית והקצאת זיכרון
  • משמש באלגוריתמי דחיסה ורבים נוספים

ערימה בינארית

ערימה בינארית היא שלמהעץ בינארי, העונה לרכוש הערימה. במילים פשוטות זההוא וריאציה של עץ בינארי עם המאפיינים הבאים:

  • ערימה היא עץ בינארי שלם: אומרים על עץ שהוא שלם אם כל הרמות שלו, למעט אולי העמוקות ביותר, שלמות. טרכושו של Binary Heap הופך אותו למאוחסן באחסון .
  • עוקב אחר רכוש ערימה: ערימה בינארית היא או Min-Heap או א מקס-הערמה .
    • ערימה בינארית מינימלית: Fאו כל צומת בערימה, ערך הצומת הוא פחות או שווה ל- ערכים של הילדים
    • ערימה בינארית מקסימלית: Fאו כל צומת בערימה, ערך הצומת הוא גדול מ או שווה ל ערכים של הילדים

יישומים פופולריים של ערימה בינארית כולליםיישום תורי עדיפות יעילים, מציאת ביעילות את האלמנטים הקטנים ביותר (או הגדולים) במערך ורבים נוספים.

שולחנות האש

דמיין שיש לך לְהִתְנַגֵד ואתה רוצה להקצות לו מפתח כדי להקל מאוד על החיפוש. כדי לאחסן את צמד המפתחות / הערכים הזה, אתה יכול להשתמש במערך פשוט כמו מבנה נתונים שבו ניתן להשתמש במפתחות (מספרים שלמים) ישירות כאינדקס לאחסון ערכי נתונים. עם זאת, במקרים בהם המקשים גדולים מדי ולא ניתן להשתמש בהם ישירות כאינדקס, משתמשים בטכניקה הנקראת hashing.

איזו שיטת מחלקה של הסורק קוראת מחרוזת

בשיש, המפתחות הגדולים מומרים למפתחות קטנים באמצעות פונקציות חשיש . הערכים נשמרים אז במבנה נתונים שנקראל טבלת גיבוב. טבלת hash היא מבנה נתונים המיישם ADT מילוני, מבנה שיכול למפות מפתחות ייחודיים לערכים.

באופן כללי, לטבלת חשיש יש שני מרכיבים עיקריים:

  1. מערך דלי: מערך דלי לטבלת hash הוא מערך A בגודל N, כאשר כל תא של A נחשב כ'דלי ', כלומר אוסף של זוגות ערכי מפתח. המספר השלם N מגדיר את קיבולת המערך.
  2. פונקציית Hash כל פונקציה היא שממפה כל מקש k במפה שלנו למספר שלם בטווח [0, N ומינוס 1], כאשר N הוא הקיבולת של מערך הדלי לטבלה זו.

כאשר אנו מכניסים אובייקטים לצילום hash, יתכן ואובייקטים שונים עשויים להיות בעלי אותו קוד hash. זה נקרא a הִתנַגְשׁוּת . כדי להתמודד עם התנגשות, יש טכניקות כמו שרשור וטיפול פתוח.

אז, אלה הם כמה מבני נתונים בסיסיים והכי נפוצים בשימוש ב- Java. עכשיו שאתה מודע לכל אחד מאלה, אתה יכול להתחיל ליישם אותם ב- שלך . בכך השלמנו את החלק הראשון במאמר 'מבני נתונים ואלגוריתמים בג'אווה'. בחלק הבא, אנו הולכים ללמוד עלאלגוריתמים בסיסיים וכיצד להשתמש בהם ביישומים מעשיים כגון מיון וחיפוש, חלוקה וכיבוש, אלגוריתמים חמדניים, תכנות דינמי.

אלגוריתמים בג'אווה

היסטורי המשמש ככלי לפתרון חישובים מתמטיים מורכבים, אלגוריתמים קשורים עמוק עם מדעי המחשב, ועם מבני נתונים בפרט. אלגוריתם הוא רצף הוראות המתאר דרך לפתור בעיה ספציפית בפרק זמן סופי. הם מיוצגים בשתי דרכים:

  • תרשימי זרימה - זהייצוג חזותי של זרימת הבקרה של האלגוריתם
  • פסאודוקוד - זההוא ייצוג טקסטואלי של אלגוריתם המקורב את קוד המקור הסופי

הערה: ביצועי האלגוריתם נמדדים על פי מורכבות הזמן ומורכבות החלל. בעיקר, המורכבות של כל אלגוריתם תלויה בבעיה ובאלגוריתם עצמו.

בואו נחקור את שתי הקטגוריות העיקריות של אלגוריתמים ב- Java, שהן:

מיון אלגוריתמים בג'אווה

אלגוריתמי מיון הם אלגוריתמים שמציבים אלמנטים של רשימה בסדר מסוים. הסדרים הנפוצים ביותר הם סדר מספרי וסדר לקסיקוגרפי. במאמר זה 'מבני נתונים ואלגוריתמים' מאפשר לחקור כמה אלגוריתמי מיון.

מיון בועות בג'אווה

מיון הבועות, המכונה לעתים קרובות מיון שוקע, הוא אלגוריתם המיון הפשוט ביותר. הוא עובר שוב ושוב ברשימה למיון, משווה כל זוג אלמנטים סמוכים ומחליף אותם אם הם בסדר הלא נכון.מין בועות מקבל את שמו מכיוון שהוא מסנן את האלמנטים בראש המערך, כמו בועות שצפות על מים.

הנהפסאוד-קוד המייצג אלגוריתם של מיון בועות (הקשר מיון עולה).

a [] הוא מערך בגודל N להתחיל BubbleSort (a []) להכריז על מספר שלם i, j עבור i = 0 עד N - 1 עבור j = 0 ל- N - i - 1 אם [j]> a [j + 1 ] ואז החלף [j], [j + 1] סוף אם סוף להחזרת BubbleSort

קוד זה מזמין מערך חד-ממדי של פריטי נתונים N בסדר עולה. לולאה חיצונית גורמת ל- N-1 לעבור על המערך. כל מעבר משתמש בלולאה פנימית כדי להחליף פריטי נתונים כך שפריט הנתונים הקטן ביותר הבא 'מבעבע' לקראת תחילת המערך. אך הבעיה היא שהאלגוריתם זקוק למעבר שלם אחד ללא כל החלפה כדי לדעת שהרשימה ממוינת.

מורכבות הזמן הגרוע והממוצע ביותר: O (n * n). המקרה הגרוע ביותר מתרחש כאשר מערך ממוין לאחור.

מורכבות הזמן הטוב ביותר: עַל). המקרה הטוב ביותר מתרחש כאשר מערך כבר ממוין.

מיון הבחירה ב- Java

מיון בחירות הוא שילוב של חיפוש וגם מיון. האלגוריתם ממיין מערך על ידי מציאת שוב ושוב את האלמנט המינימלי (בהתחשב בסדר עולה) מהחלק הלא ממוין ומציב אותו במיקום תקין במערך.

הנה פסאודוקוד המייצג אלגוריתם מיון בחירה (הקשר מיון עולה).

a [] הוא מערך בגודל N התחל SelectionSort (a []) עבור i = 0 עד n - 1 / * הגדר את האלמנט הנוכחי כמינימום * / min = i / * מצא את האלמנט המינימלי * / עבור j = i + 1 ל- n אם רשימה [j]

כפי שניתן להבין מהקוד, מספר הפעמים שהמיון עובר במערך הוא פחות ממספר הפריטים במערך. הלולאה הפנימית מוצאת את הערך הקטן ביותר הבא והלולאה החיצונית ממקמת את הערך במיקומו הנכון. מיון הבחירה לעולם אינו מבצע יותר מ- O (n) החלפות ויכול להיות שימושי כאשר כתיבת הזיכרון היא פעולה יקרה.

מורכבות זמן: עַל2) שכן ישנם שני לולאות מקוננות.

מרחב עזר: או (1).

מיון הכנסה ב- Java

מיון הוספה הוא אלגוריתם מיון פשוט אשר חוזר ברשימה על ידי צריכת אלמנט קלט אחד בכל פעם ובונה את מערך המיון הסופי. זה פשוט מאוד ויעיל יותר בערכות נתונים קטנות יותר. זוהי טכניקת מיון יציבה במקום.

הנה פסאודוקוד המייצג אלגוריתם מיון הכנסה (הקשר מיון עולה).

a [] הוא מערך בגודל N מתחיל InsertionSort (a []) עבור i = 1 עד N מפתח = a [i] j = i - 1 ואילו (j> = 0 ו- [j]> key0 a [j + 1] = x [j] j = j - קצה אחד ואילו [j + 1] = סוף מקש לקצה InsertionSort

כפי שאתה יכול להבין מהקוד, אלגוריתם מיון ההכנסהמסיר אלמנט אחד מנתוני הקלט, מוצא את המיקום שהוא שייך ברשימה הממוינת ומכניס אותו לשם. הוא חוזר על עצמו עד ששום אלמנט קלט לא נותר ממוין.

המקרה הטוב ביותר: המקרה הטוב ביותר הוא כאשר קלט הוא מערך שכבר ממוין. במקרה זה למיון ההכנסה יש זמן ריצה ליניארי (כלומר, & תטא (n)).

במקרה הגרוע ביותר: הקלט הפשוט ביותר במקרה הגרוע הוא מערך הממוין בסדר הפוך.

QuickSort בג'אווה

אלגוריתם מהיר הוא אלגוריתם מין מהיר, רקורסיבי, שאינו יציב, הפועל על פי עקרון החלוקה והכיבוש. הוא בוחר אלמנט כציר ומחלק את המערך הנתון סביב הציר שנבחר.

שלבים ליישום מיון מהיר:

  1. בחר 'נקודת ציר' מתאימה.
  2. חלק את הרשימות לשתי רשימותמבוסס על אלמנט ציר זה. כל אלמנט שהוא קטן יותר מאלמנט הציר ממוקם ברשימה השמאלית וכל אלמנט שהוא גדול יותר ממוקם ברשימה הימנית. אם אלמנט שווה לאלמנט הציר, הוא יכול להיכנס לכל רשימה. זה נקרא פעולת המחיצה.
  3. ממיין רקורסיבית כל אחת מהרשימות הקטנות יותר.

הנה פסאודוקוד המייצג את האלגוריתם של Quicksort.

QuickSort (A כמערך, נמוך כמו int, גבוה כמו int) {אם (נמוך

בפסאוד-קוד לעיל, חֲלוּקָה() פונקציה מבצעת פעולת מחיצה סיבוב מהיר () function קוראת שוב ושוב לפונקציית המחיצה עבור כל רשימה קטנה יותר שנוצרה. המורכבות של quicksort במקרה הממוצע היא & Theta (n log (n)) ובמקרה הגרוע ביותר היא & Theta (n2).

מיזוג מיון ב- Java

Mergesort הוא אלגוריתם מין מהיר, רקורסיבי, יציב אשר פועל גם על פי עקרון הפיצול והכיבוש. בדומה למצב מהיר, מיון מיזוג מחלק את רשימת האלמנטים לשתי רשימות. רשימות אלה ממוינות באופן עצמאי ואז משולבות. במהלך שילוב הרשימות, האלמנטים מוכנסים (או מוזגים) במקום הנכון ברשימה.

הנה פסאודוקוד המייצג אלגוריתם מיזוג מיזוג.

הליך MergeSort (a כמערך) אם (n == 1) להחזיר var l1 כמערך = a [0] ... a [n / 2] var l2 כמערך = a [n / 2 + 1] ... a [n] l1 = מיזוג (l1) l2 = מיזוג (l2) מיזוג החזרה (l1, l2) נוהל סיום הליך מיזוג (a כמערך, b כמערך) var c כמערך ואילו (a ו- b יש אלמנטים) אם ( a [0]> b [0]) הוסף b [0] לסוף c הסר b [0] מ b אחר הוסף [0] לסוף c הסר a [0] מקצה אם סיום תוך כדי (a יש אלמנטים) להוסיף a [0] לסוף c להסיר a [0] מהקצה בזמן ש (b יש אלמנטים) להוסיף b [0] לסוף c להסיר את b [0] מקצה b בזמן החזרה הליך סיום

מיזוג () פונקציה מחלקת את הרשימה לשניים, שיחות מיזוג () ברשימות אלה בנפרד ואז משלב אותן על ידי שליחתן כפרמטרים למיזוג () פונקציה.האלגוריתם מורכב של O (n log (n)) ויש לו מגוון רחב של יישומים.

ערימת מיון בג'אווה

Heapsort הוא אלגוריתם מיון מבוסס השוואהמבנה נתונים של ערימה בינארית. אתה יכול לחשוב על זה כעל גרסה משופרת של מיון, איפההוא מחלק את קלטו לאזור ממוין ולא ממוין, והוא מכווץ באופן איטרטיבי את האזור הלא ממוין על ידי חילוץ האלמנט הגדול ביותר והעברתו לאזור הממוין.

השלבים ליישום Quicksort (בסדר הולך וגדל):

  1. בנה ערימה מקסימלית עם מערך המיון
  2. בנקודה זוt, הפריט הגדול ביותר מאוחסן בשורש הערמה. החלף אותו בפריט האחרון של הערימה והקטן את גודל הערמה ב- 1. לבסוף, גבה את שורש העץ
  3. חזור על השלבים שלמעלה עד שגודל הערמה גדול מ -1

הנה פסאוד-קוד המייצג אלגוריתם של ערימת ערימה.

Heapsort (a כמערך) עבור (i = n / 2 - 1) ל- i> = 0 heapify (a, n, i) עבור i = n-1 ל- 0 החלפה (a [0], a [i]) heapify (a, i, 0) קצה לקצה עבור heapify (a כמערך, n כ int, i כ int) הגדול ביותר = i // אתחל הגדול כ root int l eft = 2 * i + 1 // left = 2 * i + 1 int ימין = 2 * i + 2 // right = 2 * i + 2 if (שמאל a [הגדול ביותר]) הגדול ביותר = שמאל אם (ימינה a [הגדול ביותר]) הגדול ביותר = ימינה אם (הגדול ביותר! = I) החלפה ( a [i], A [הגדול ביותר]) Heapify (a, n, הגדול ביותר) סוף heapify

מלבד אלה, ישנם אלגוריתמי מיון אחרים שאינם כל כך ידועים כמו Introsort, Counting Sort וכו '. מעבר למערכת האלגוריתמים הבאה במאמר זה' מבני נתונים ואלגוריתמים ', בואו נחקור אלגוריתמי חיפוש.

חיפוש אלגוריתמים בג'אווה

חיפוש הוא אחת הפעולות הנפוצות ביותר המבוצעות בתדירות גבוהה ביישומים עסקיים רגילים. אלגוריתמי חיפוש הם אלגוריתמים למציאת פריט עם מאפיינים מוגדרים בין אוסף פריטים. בואו לחקור שניים מאלגוריתמי החיפוש הנפוצים ביותר.

אלגוריתם חיפוש ליניארי בג'אווה

חיפוש לינארי או חיפוש רציף הוא אלגוריתם החיפוש הפשוט ביותר. זה כרוך בחיפוש רציף אחר אלמנט במבנה הנתונים הנתון עד אשר נמצא האלמנט או שמגיעים לסוף המבנה. אם נמצא האלמנט, מיקום הפריט מוחזר אחרת האלגוריתם מחזיר NULL.

הנה פסאוד-קוד המייצג חיפוש לינארי ב- Java:

נוהל חיפוש_ליניארי (a [], ערך) עבור i = 0 עד n-1 אם ערך [i] = אז הדפיס 'נמצא' החזר אני סוף אם הדפסה 'לא נמצא' סוף לסוף ליניארי_סוף

זהאלגוריתם כוח ברוט.אמנם זה בהחלט הפשוט ביותר, אך בהחלט אינו הנפוץ ביותר, בגלל חוסר היעילות שלו. מורכבות הזמן של חיפוש לינארי היא עַל) .

אלגוריתם חיפוש בינארי בג'אווה

חיפוש בינארי, המכונה גם חיפוש לוגריתמי, הוא אלגוריתם חיפוש שמוצא את המיקום של ערך יעד בתוך מערך שכבר מיון. הוא מחלק את אוסף הקלט לחצאים שווים והפריט מושווה לאלמנט האמצעי ברשימה. אם האלמנט נמצא, החיפוש מסתיים שם. אחרת, אנו ממשיכים לחפש את האלמנט על ידי חלוקה ובחירה של המחיצה המתאימה למערך, על סמך אם אלמנט היעד קטן או גדול יותר מאלמנט האמצעי.

הנה פסאוד-קוד המייצג חיפוש בינארי בג'אווה:

נוהל בינארי_חפש מערך ממוין n גודל מערך x ערך לחיפוש lowerBound = 1 upperBound = n בעוד ש- x לא נמצא אם upperBound

החיפוש מסתיים כאשר ה- UpperBound (המצביע שלנו) עובר מעבר ל- LowerBound (האלמנט האחרון), מה שמרמז שחיפשנו את כל המערך והאלמנט אינו קיים.זהו אלגוריתמי החיפוש הנפוצים ביותר בעיקר בזכות זמן החיפוש המהיר שלו. מורכבות הזמן של החיפוש הבינארי היא עַל) המהווה שיפור ניכר ב- עַל) מורכבות זמן של חיפוש לינארי.

באמצעות מרחב השמות c ++

זה מביא אותנו לסוף מאמר זה 'מבני נתונים ואלגוריתמים בג'אווה'. סקרתי את אחד הנושאים הבסיסיים והחשובים ביותר של Java.מקווה שברור לך עם כל מה ששותף איתך במאמר זה.

דאג שתתאמן ככל האפשר ותחזיר את החוויה שלך.

בדוק את מאת אדוריקה, חברת למידה מקוונת מהימנה עם רשת של יותר מ -250,000 לומדים מרוצים הפרוסים ברחבי העולם. אנו כאן כדי לעזור לך בכל שלב בדרכך, ולהיות מלבד שאלות ראיונות אלה ב- Java, אנו מגישים תוכנית לימודים המיועדת לסטודנטים ואנשי מקצוע המעוניינים להיות מפתח Java.

יש לך שאלה עבורנו? אנא הזכיר זאת בסעיף ההערות של 'מבני נתונים ואלגוריתמים בג'אווה'. מאמר ונחזור אליך בהקדם האפשרי.