1. Sorting II: הפרד ומשול

2. Last week: in-place sorting Bubble Sort – O(n 2 ) comparisons –O(n) best case comparisons, O(n 2 ) exchanges Selection Sort - O(n 2 ) comparisons –O(n 2 ) best case comparisons –O(n) exchanges (always) Insertion Sort – O(n 2 ) comparisons –O(n) best case comparisons –Fewer exchanges than bubble sort –Best in practice for small lists (<30)

3. This week Mergesort –O(n log n) always –O(n) storage Quick sort –O(n log n) average, O(n^2) worst –Good in practice (>30), O(log n) storage

4. MergeSort A divide-and-conquer technique Each unsorted collection is split into 2 –Then again Then again –Then again »……. Until we have collections of size 1 »Now we merge sorted collections –Then again Then again –Then again Until we merge the two halves

5. MS(N) Merge sort analysis = N = N/2 + N/2 MS(N/2) + N/4 N/4 = 4*N/4 + N/8 N/8 N/8 N/8 + = 8*N/8 Each level contributes N...

6. MS(N) Merge sort analysis MS(N/2) N/4 N/4 N/8 N/8 N/8 N/8 N/2 K = 1 N = 2 K lg N = K log n levels * n per level= O( nlog(n) ) K levels … N/2 K

7. MergeSort(array a, indexes low, high) 1.If (low < high) 2. middle  (low + high) /2 3. MergeSort(a,low,middle) // split 1 4. MergeSort(a,middle+1,high) // split 2 5. Merge(a,low,middle,high) // merge 1+2

8. Merge(arrays a, index low, mid, high) 1.b  empty array, t  mid+1, i  low, tl  low 2.while (tl<=mid AND t<=high) 3. if (a[tl]<=a[t]) 4. b[i]  a[tl] 5. i  i+1, tl  tl+1 6. else 7. b[i]  a[t] 8. i  i+1, t  t+1 9.if tl<=mid copy a[tl…mid] into b[i…] 10.else if t<=high copy a[t…high] into b[i…] 11.copy b[low…high] onto a[low…high]

9. דוגמא Initial: 25 57 48 37 12 92 86 33 Split: 25 57 48 37 12 92 86 33 Merge: 25 57 37 48 12 92 33 86 Merge: 25 37 48 57 12 33 86 92 Merge: 12 25 33 37 48 57 86 92

10. The complexity of MergeSort Every split, we half the collection How many times can this be done? We are looking for x, where 2 x = n x = log 2 n So there are a total of log n splits

11. The complexity of MergeSort Each merge is of what run-time? First merge step: n/2 merges of 2  n Second merge step: n/4 merges of 4  n Third merge step: n/8 merges of 8  n …. How many merge steps? Same as splits log n Total: n log n steps

12. Storage complexity of MergeSort Every merge, we need to hold the merged array: 1 2 3 4 5 6 1 2 3 4 1 2 3 4 5 6

13. Storage complexity of MergeSort So we need temporary storage for merging –Which is the same size as the two collections together To merge the last two sub-arrays (each size n/2) We need n/2+n/2 = n temporary storage Total: O(n) storage

14. QuickSort Key idea: Select a item (called the pivot) Put it into its proper FINAL position Make sure: –All greater item are on one side (side 1) –All smaller item are on other side (side 2) Repeat for side 1 Repeat for side 2

15. Short example 25 57 48 37 12 92 86 33 Let’s select 25 as our initial pivot. We move items such that: –All left of 25 are smaller –All right of 25 are larger –As a result 25 is now in its final position 12 25 57 48 37 92 86 33

16. Now, repeat (recursively) for left and right sides 12 25 57 48 37 92 86 33 –Sort 12 –Sort 57 48 37 92 86 33 12 needs no sorting For the other side, we repeat the process –Select a pivot item (let’s take 57) –Move items around such that left items are smaller, etc.

17. 12 25 57 48 37 92 86 33 Changes into 12 25 48 37 33 57 92 86 And now we repeat the process for left 12 25 37 33 48 57 92 86 12 25 33 37 48 57 92 86 And for the right 12 25 33 37 48 57 86 92

18. QuickSort(array a; index low, hi) 1.if (low >= hi) 2. return ; // a[low..hi] is sorted 3.pivot  find_pivot(a,low,hi) 4.p_index=partition(a,low,high,pivot) 5.QuickSort(a,low,p_index-1) 6.QuickSort(a,p_index+1,hi)

19. Key questions How do we select an item (FindPivot())? If we always select the largest item as the pivot –Then this process becomes Selection Sort –Which is O(n 2 ) So this works only if we select items “in the middle” –Since then we will have log n divisions How do we move items around efficiently (Partition()?) This offsets the benefit of partitioning

20. FindPivot To find a real median (middle item) takes O(n) In practice however, we want this to be O(1) So we approximate: –Take the first item (a[low]) as the pivot –Take the median of {a[low],a[hi],a[(low+hi)/2]} FindPivot(array a; index low, high) 1.return a[low]

21. Partition (in O(n)) Key idea: Keep two indexes into the array –up points at lowest item >= pivot –down points at highest item <= pivot We move up, down in the array Whenever they point inconsistently, interchange At end: up and down meet in location of pivot

22. partition(array a; index low,hi; pivot; index pivot_i) 1.down  low, up  hi 2.while(down<up) 3. while (a[down]<=pivot && down<hi) 4. down  down + 1 5. while (a[hi]>pivot) 6. up  up – 1 7. if (down < up) 8. swap(a[down],a[up]) 9.a[pivot_i]=a[up] 10.a[up] = pivot 11.return up

23. Example: partition() with pivot=25 First pass through loop on line 2: 25 57 48 37 12 92 86 33 down up

24. Example: partition() with pivot=25 First pass through loop on line 2: 25 57 48 37 12 92 86 33 down up We go into loop in line 3 (while a[down]<=pivot)

25. Example: partition() with pivot=25 First pass through loop on line 2: 25 57 48 37 12 92 86 33 down up We go into loop in line 5 (while a[up]>pivot)

26. Example: partition() with pivot=25 First pass through loop on line 2: 25 57 48 37 12 92 86 33 down up We go into loop in line 5 (while a[up]>pivot)

27. Example: partition() with pivot=25 First pass through loop on line 2: 25 57 48 37 12 92 86 33 down up Now we found an inconsistency!

28. Example: partition() with pivot=25 First pass through loop on line 2: 25 12 48 37 57 92 86 33 down up So we swap a[down] with a[up]

29. Example: partition() with pivot=25 Second pass through loop on line 2: 25 12 48 37 57 92 86 33 down up

30. Example: partition() with pivot=25 Second pass through loop on line 2: 25 12 48 37 57 92 86 33 down up Move down again (increasing) – loop on line 3

31. Example: partition() with pivot=25 Second pass through loop on line 2: 25 12 48 37 57 92 86 33 down up Now we begin to move up again – loop on line 5

32. Example: partition() with pivot=25 Second pass through loop on line 2: 25 12 48 37 57 92 86 33 down up Again – loop on line 5

33. Example: partition() with pivot=25 Second pass through loop on line 2: 25 12 48 37 57 92 86 33 down up down < up? No. So we don’t swap.

34. Example: partition() with pivot=25 Second pass through loop on line 2: 25 12 48 37 57 92 86 33 down up Instead, we are done. Just put pivot in place.

35. Example: partition() with pivot=25 Second pass through loop on line 2: 12 25 48 37 57 92 86 33 down up Instead, we are done. Just put pivot in place. (swap it with a[up] – for us a[low] was the pivot)

36. Example: partition() with pivot=25 Second pass through loop on line 2: 12 25 48 37 57 92 86 33 down up Now we return 2 as the new pivot index

37. Notes We need the initial pivot_index in partition() For instance, change FindPivot(): –return pivot (a[low]), as well as initial pivot_index (low) –Then use pivot_index in the final swap QuickSort: Average O(n log n), Worst case O(n 2 ) –works very well in practice (collections >30) –Average O(n log n), Worst case O(n 2 ) –Space requirements O(log n) – for recursion

38. סבוכיות: ממוצע (O(nlogn גרוע ביותר (O(n 2 מיון של האיברים [A[j],…., A[i במקום שיטה: 1) בחר פיבוט, V (אחד מערכי [A[j],…..,A[i) 2) מצא (וארגן) נקודה k כך ש: הערכים הקטנים מ- V מופיעים ב- [A[j],…..,A[k והגדולים שווים ל- V מופיעים ב- [A[k+1],…..,A[i 3) מיין את [A[j],…..,A[k ו- [A[k+1],…..,A[i רקורסיבית דוגמא לפיבוט: האיבר הגדול ביותר בין השניים השונים זה מזה משמאל QUICKSORT

39. האלגוריתם מורכב מ: 1) מציאת פיבוט FindPivot 2) חלוקה Partition 3) רקורסיה לך משמאל לימין ומצא את הגדול הראשון מבין השניים השתמש בשני סמנים L, R. R מתחיל מימין וזז שמאלה L מתחיל משמאל וזז ימינה 1. הסע R שמאלה כל עוד הערכים גדולים שווים מ Pivot 2. הסע L ימינה כל עוד הערכים קטנים מ Pivot 3. אם L>R עצור. אחרת: החלף בין האיברים של L ו- R הזז R שמאלה הזז L ימינה חזור ל 1. (R = L - 1) בדיקה !!!!

40. ב) QuickSort- פרט לקריאה הרקורסיבית, הכל לינארי במספר האלמנטים זמן כולל: סכם על כל האלמנטים את מספר הפעמים שמשתתפים בקריאה = סכום העומקים של האלמנטים (כולם) ניתוח סיבוכיות: א) נראה ש (Partition(i, j לוקחת (O(j - i + 1 - התחשבנות עם כל איבר - לכל איבר מתבצע: א) הגעה עם המצביע ב) אחד מהשניים: 1) ממשיכים עם מצביע- (O(1 2) 1. ממתינים 2. מחליפים (O(1 3. מקדמים מצביע - לא חוזרים לאיבר מסקנה: סיבוכיות (Partition(i, j היא (O(j - i + 1

41. ג) Worst Case אם כל פעם נבחר לפיבוט את הגדול ביותר אז המערך בגודל n יתחלק למערך של 1 + מערך של n -1 n n - 1 n - 2 2 n - 1 סכום העבודה בכל הרמות (עבודה לינארית באלמנטים) = סכום העומקים = n - 1 + (1 + 2 + …… + n - 1) = O(n 2 ) =

42. ד) ממוצע הנחה 1: כל האלמנטים שונים זה מזה (אלמנטים זהים רק מקטינים סיבוכיות) הנחה 2: כל הסדרים של [A[i],…,A[j שווי הסתברות! נכון?!? בעד: אי אפשר להבחין בין האלמנטים כי כולם היו גדולים שווים לפיבוט הקודם נאמץ את ההנחה! נגד: בניתוח מדוקדק- הפיבוט הקודם בד”כ בצד ימין של המערך הימני בכל זאת: - לא כל כך משמעותי (איבר בודד) - אם כן משמעותי: ערבב האיברים בצורה אקראית

43. סימון: (T(n זמן מיון מערך בגודל n. הסתברויות: ראשון הוא i + 1st שני קטן מ i + 1 החלף בין בני הזוג

44. נניח : נוכיח ( באינדוקציה ): אם C=4C 2

45. QuickSort- המהיר ביותר בממוצע מכל אלגוריתמי ה nlogn זרוז האלגוריתם: נוכל לדאוג שהפיבוט יהיה מרכזי יותר. דוגמה: האמצעי מבין שלושה אלמנטים דוגמה: קח k אלמנטים ובחר אמצעי TradeOff : k קטן  חוסר איזון k גדול  מציאת אמצעי יקרה החלטה על סיום האלגוריתם: - אנחנו סיימנו ב n = 2 - עבור n קטן לא אכפת לנו שהסיבוכיות תהיה (O(n 2 - Knuth ממליץ על n = 9 שימוש בפוינטרים לרשומות: - חוסך העתקות - עולה במצביעים

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

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

48. פעולות של מבנה הנתונים "ערימה" צור ערימה ריקה (make_heap(Q)) הכנס רשומה בעלת מפתח x לערימה ) insert (Q,x)) הדפס את הרשומה בעלת המפתח הגדול ביותר בערימה (max(Q)) הוצא את הרשומה בעלת המפתח הגדול ביותר בערימה(del_max(Q)) הדפס את כל הרשומות בסדר יורד (heap_sort(Q))

49. הגדרה: עץ בינארי שלם עץ בינארי הוא עץ, שלכל צומת שלו יש לכל היותר שני בנים, ולכל צומת מלבד השורש יש בדיוק אבא אחד. עץ בינארי מלא הוא עץ שבו לכל צומת מלבד העלים יש בדיוק 2 בנים. עץ בינארי שלם הוא עץ בינארי מלא שבו כל העלים הם בעלי אותו עומק. עץ בינארי כמעט שלם הוא עץ בינארי שלם שהוצאו ממנו עלים "מימין".

50. דוגמאות לעצים בינאריים עץ בינארי עץ בינארי כמעט שלםעץ בינארי מלא עץ בינארי שלם

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

52. דוגמא לערימת מקסימום 17 1117 1512910 6289 כל מסלול בעץ היוצא מהשורש הוא מסלול לא עולה השורש הוא המפתח המקסימלי בעץ

53. כל מערך יכול לייצג עץ בינארי כמעט מלא כל איבר במערך מייצג צומת בעץ לכל איבר i במערך, בניו בעץ יושבים במקומות 2i ו – 2i+1 במערך. אביו של האיבר ה - i במערך הוא האיבר ה – [i/2] שורש העץ הוא האיבר הראשון במערך עלי העץ הם האיברים שבניהם לא נכללים בתחום המערך

54. דוגמא להשמת עץ בינארי כמעט שלם בתוך מערך 17 1117 1512910 6289 17111710912156289 1234567891011 כל מערך יכול לייצג עץ בינארי כמעט שלם, וכל עץ בינארי כמעט שלם יכול להיות מיוצג בעזרת מערך

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

56. פעולת Shift_down(v) קלט: ערימה שהשורש שלה לא מקיים את תכונת הערימה פלט: ערימה תקנית פעולת Shift_down(v) 1.אם v עלה, או v גדול משני בניו, סיים 2.החלף את ערכו של v עם הערך של הגדול משני בניו (בסימון w) 3.חזור על הפעולה עם הערימה ששורשה הוא w.

57. דוגמא לפעולת Shift_down 8 1716 1512910 6289 קלט : עץ בו השורש לא מקיים את כללי הערימה

58. דוגמא לפעולת Shift_down 17 816 1512910 6289

59. דוגמא לפעולת Shift_down 17 1016 151298 6289

60. 17 1016 151298 6289

61. 17 1016 151298 6289 פלט : ערימה תקינה

62. בניית ערימה ממערך נתון כלשהו A Make_heap(A) 1.עבור על כל איברי המערך מימין לשמאל 2.עבור כל אחד מהם בצע Shift_down.

63. דוגמא ליצירת ערימה 6812582310631749 1234567891011 6 812 102385 631749 קלט : מערך כלשהו

64. דוגמא ליצירת ערימה - המשך 6812582310631749 1234567891011

65. דוגמא ליצירת ערימה - המשך 6812582310631749 1234567891011

66. דוגמא ליצירת ערימה - המשך 6812582310631749 1234567891011

67. דוגמא ליצירת ערימה - המשך 6812582310631749 1234567891011

68. דוגמא ליצירת ערימה - המשך 6812582310631749 1234567891011

69. דוגמא ליצירת ערימה - המשך 6812582310631749 1234567891011

70. דוגמא ליצירת ערימה - המשך 6812592310631748 1234567891011

71. דוגמא ליצירת ערימה - המשך 6812639231051748 1234567891011

72. דוגמא ליצירת ערימה - המשך 6823639121051748 1234567891011

73. דוגמא ליצירת ערימה - המשך 6632389121051748 1234567891011

74. דוגמא ליצירת ערימה - המשך 6632317912105848 123456789 11

75. דוגמא ליצירת ערימה - המשך 6362317912105848 123456789 11

76. דוגמא ליצירת ערימה - המשך 6317236912105848 123456789 11

77. דוגמא ליצירת ערימה - המשך 6317238912105648 123456789 11

78. דוגמא ליצירת ערימה - המשך 6317238912105648 123456789 11 63 1723 101298 5648 פלט : ערימת מקסימום

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

80. זמן ריצה של בניית ערימה זמן ריצה של בניית ערימה הוא סכום גבהי כל הצמתים בעץ: משפט: סכום הגבהים של כל הצמתים בעץ בינארי שלם בעל n צמתים ובגובה H קטן מ – n. הוכחת המשפט: קודם כל יש לשים לב שעבור עץ בינארי שלם מתקיים

81. המשך הוכחת המשפט ישנו צומת בודד בגובה H (השורש), שני צמתים בגובה H-1 (בניו של השורש), 4 צמתים בגובה H-2,..., ובאופן כללי יש צמתים בגובה H-i. לפיכך נסכום ונקבל: מש " ל

82. מימוש הפעולות max(Q) ו – del_max(Q) פעולת max(Q): 1.הדפס את שורש העץ (האיבר הראשון במערך) –זמן הפעולה O(1) פעולת del_max(Q): 1.העבר את העלה הימני ביותר בעץ (האיבר האחרון במערך) למקום השורש r (המקום הראשון במערך) 2.בצע shift_down(r) –זמן הפעולה O(log n) –שימו לב שפעולה זו מחזירה ערימה תקינה אחרי הוצאת השורש מהערימה המקורית

83. מיון Heap_sort(A) Heap_Sort(A) 1.Q=Make_heap(A) 2.For i=1 to |A| do 3. print max(Q) 4. del_max(Q) הערה : במימוש ע " י מערך נהוג בפעולת del_max(Q) לא " לזרוק " את האיבר הגדול ביותר, אלא להחליפו עם האיבר האחרון במערך ואז לבצע shift_down. בצורה זו מתקבל מערך ממוין. כמובן שמחשיבים כ " ערימה " רק את האיברים המקוריים ללא תוספת הגדולים מימין.

84. דוגמא מלאה ל – Heap_sort(A) 6812582310631749 1234567891011 6 812 102385 631749 A = קלט : מערך A כלשהו

85. דוגמא - המשך 6317238912105648 123456789 11 63 1723 101298 5648 Q = הערימה

86. דוגמא - המשך 8172389121056463 1234567891011 8 1723 101298 564 Q = ביטול הערך 63 על ידי החלפתו עם העלה הימני ביותר בעץ

87. דוגמא - המשך 2317889121056463 1234567891011 23 178 101298 564 Q = Shift_down(8)

88. דוגמא - המשך 2317128981056463 1234567891011 23 1712 10898 564 Q = Shift_down(8)

89. דוגמא - המשך 4171289810562363 1234567891011 4 1712 10898 56 Q = Del_max(Q)

90. דוגמא - המשך 1741289810562363 1234567891011 17 412 10898 56 Q = Shift_dowb(4)

91. דוגמא - המשך 1791284810562363 1234567891011 17 912 10848 56 Q = Shift_dowb(4)

92. דוגמא - המשך 6912848105172363 1234567891011 6 912 10848 5 Q = Del_max(Q)

93. דוגמא - המשך 1296848105172363 1234567891011 12 96 10848 5 Q = Shift_down(6)

94. דוגמא - המשך 1291084865172363 1234567891011 12 910 6848 5 Q = Shift_down(6)

95. דוגמא - המשך 5910848612172363 1234567891011 5 910 6848 Q = Del_max(Q)

96. דוגמא - המשך 1095848612172363 1234567891011 10 95 6848 Q = Shift_down(5)

97. דוגמא - המשך 1098845612172363 1234567891011 10 98 6548 Q = Shift_down(5)

98. דוגמא - המשך 6988451012172363 1234567891011 6 98 548 Q = Del_max(Q)

99. דוגמא - המשך 9688451012172363 1234567891011 9 68 548 Q = Shift_down(6)

100. דוגמא - המשך 9886451012172363 1234567891011 9 88 546 Q = Shift_down(6)

101. דוגמא - המשך 5886491012172363 1234567891011 5 88 46 Q = Del_max(Q)

102. דוגמא - המשך 8586491012172363 1234567891011 8 58 46 Q = Shift_down(5)

103. דוגמא - המשך 8685491012172363 1234567891011 8 68 45 Q = Shift_down(5)

104. דוגמא - המשך 4685891012172363 1234567891011 4 68 5 Q = Del_max(Q)

105. דוגמא - המשך 8645891012172363 1234567891011 8 64 5 Q = Shift_down(4)

106. דוגמא - המשך 5648891012172363 1234567891011 5 64 Q = Del_max(Q)

107. דוגמא - המשך 6548891012172363 1234567891011 6 54 Q = Shift_down(5)

108. דוגמא - המשך 4568891012172363 1234567891011 4 5 Q = Del_max(Q)

109. דוגמא - המשך 5468891012172363 1234567891011 5 4 Q = Shift_down(4)

110. דוגמא - המשך 4568891012172363 1234567891011 4 Q = Del_max(Q)

111. דוגמא - המשך 4568891012172363 1234567891011 4 Q = Shift_down(4)

112. דוגמא - המשך 4568891012172363 1234567891011 Q = Del_max(Q)

113. בסוף האלגוריתם: המערך ממוין 4568891012172363 1234567891011 Q =

114. אנליזת מקום וזמן של Heap_sort(A) אנליזת מקום: כל הפעולות מתרחשות בתוך המערך שגודלו n, עם תוספות מקום של O(1), לכן המקום הוא O(n). אנליזת זמן: בניית ערימה O(n) בתוספת n פעולות של del_max(Q), לכן זמן הריצה עבור מיון זה:

115. מיון BucketSort מיון n מספרים שונים בתחום 1-k נשתמש במערך בוליני A באורך k 1 2 3 4 5 6 7 8 9 3, 5, 7, 1, 9, 6 1 1 1 1 1 1 1. אפס את A. 2. לכל x בקלט בצע :A[x] = 1 3. עבור על המערך ואסוף :for (i = 1; i < k ; i++) { if (A[i] = = 1 ) output i ; } 135679

116. 1. אפס את A. 2. לכל x בקלט בצע :A[x] = 1 3. עבור על המערך ואסוף :for (i = 1; i < k ; i++) { if (A[i] = = 1 ) output i ; } סיבוכיות מיון BucketSort מיון n מספרים שונים בתחום 1-k אם סבוכיות זמן סתירה לחסם התחתון!

117. מיון BucketSort מיון n מספרים שאינם בהכרח שונים בתחום 1-k 3, 5, 3, 1, 9, 5, 3 3 1, 5 1, 3 2, 1 1, 9 1, 5 2, 3 3 מיון יציב Stable sort 1 1, 3 1, 3 2, 3 3, 5 1, 5 2, 9 1 נשתמש במערך A באורך k של תורים 1 2 3 4 5 6 7 8 9 1 3131 32323 5151 5252 9191 סבוכיות זמן

118. מיון BucketSort סבוכיות זמן אם סבוכיות זמן אם סבוכיות זמן שיטת BucketSort אינה יעילה כאשר n המספרים לקוחים מתחום " רחב מדי " 1..k, כלומר כאשר n << k

119. 321 123 231 132 213 312 111 223 332 213 321 231 111 132 312 332 123 213 223 213 1 1 1 2 2 3 2 3 3 4 111 123 132 213 223 231 312 321 331 321 123 231 132 213 312 111 223 332 213 מיון RadixSort Least Significant Digits

120. Radix-Sort(A,d) for i  1 to d do use BucketSort to sort array A on digit i מיון RadixSort סבוכיות זמן RadixSort מיון מספרים אם בסיס RadixSort ממין מספרים

121. דוגמה סבוכיות זמן אם תחום המספרים סבוכיות זמן מיון BucketSort מיון RadixSort בסיס סבוכיות זמן