1. תרגול 11
מיון בזמן לינארי
DS162-ps11

2. מה היה לנו עד כה פגשנו מיונים מבוססי השוואות.
מיון הכנסה, מיון מיזוג, מיון מהיר.
זמני הריצה היו 𝑂 𝑛 2 , 𝑂 𝑛⋅ log 𝑛 .
DS162-ps11

3. מה יהיה לנו נרצה לשפר את זמן המיון.
בעזרת ידע מוקדם על הקלט נשפר את זמן הריצה ללינארי.
DS162-ps11

4. Counting-Sort
אלגוריתם מיון שאינו מבוסס על השוואות ותומך בחזרה של מפתחות.
A הינו מערך הקלט באורך n.
B הינו מערך הפלט ואורכו גם כן n.
C הינו מערך עזר בגודל k.
הנחה: מערך הקלט A מכיל ערכים שלמים חיוביים בטווח 1…𝑘 .
DS162-ps11

5. Counting-Sort רעיון האלגוריתם:
נספור כמה פעמים מופיע כל אחד מהאיברים.
לפי הספירה נדע איך לסדר את האיברים.
המיון הינו יעיל אך הקבועים שלו גדולים. (עוד מערכים וכו')
DS162-ps11

6. Counting-Sort
for i ← 1 to k C[i] ← = 0 for j ← 1 to n C[A[j]] ← C[A[j]] + 1 // C[i] = the number of appearances of i in A. for i ← 2 to k C[i] ← C[i] + C[i-1] // C[i] = the number of elements in A that are ≤ i for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] - 1 return B
DS162-ps11

7. Counting-Sort for i ← 1 to k C[i] ← = 0 A 1 3 2 C DS162-ps11
DS162-ps11

8. Counting-Sort
for j ← 1 to n C[A[j]] ← C[A[j]] + 1 // C[i] = the number of appearances of i in A 1 3 2 C 3 1 2
DS162-ps11

9. Counting-Sort
for i ← 2 to k C[i] ← C[i] + C[i-1] // C[i] = the number of elements in A that are ≤ i A 1 3 2 C 6 3 2
DS162-ps11

10. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 A 1 3 2 C 6 3 2 B
DS162-ps11

11. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=6, A[6]=1, C[1]=2 A 1 3 2 C 6 3 2 B
DS162-ps11

12. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=6, A[6]=1, C[1]=2 A 1 3 2 C 6 3 1 B 1
DS162-ps11

13. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=5, A[5]=3, C[3]=6 A 1 3 2 C 6 3 1 B 1
DS162-ps11

14. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=5, A[5]=3, C[3]=6 A 1 3 2 C 5 3 1 B 3 1
DS162-ps11

15. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=4, A[4]=1, C[1]=1 A 1 3 2 C 5 3 1 B 3 1
DS162-ps11

16. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=4, A[4]=1, C[1]=1 A 1 3 2 C 5 3 B 3 1
DS162-ps11

17. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=3, A[3]=3, C[3]=5 A 1 3 2 C 5 3 B 3 1
DS162-ps11

18. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=3, A[3]=3, C[3]=5 A 1 3 2 C 4 3 B 3 1
DS162-ps11

19. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=2, A[2]=2, C[2]=3 A 1 3 2 C 4 3 B 3 1
DS162-ps11

20. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=2, A[2]=2, C[2]=3 A 1 3 2 C 4 2 B 3 2 1
DS162-ps11

21. Counting-Sort
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=1, A[1]=3, C[3]=4 A 1 3 2 C 4 2 B 3 2 1
DS162-ps11

22. Counting-Sort לא! מדוע? האם יתכנו מספרים שליליים במערך המקורי?
for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] – 1 j=1, A[1]=3, C[3]=4
האם יתכנו מספרים שליליים במערך המקורי?
לא! מדוע? A 1 3 2
למה צועדים בשלב האחרון מהסוף להתחלה? C 3 2 B 3 2 1
DS162-ps11

23. זמן ריצה -Counting sort
for i ← 1 to k C[i] ← = 0 for j ← 1 to n C[A[j]] ← C[A[j]] + 1 // C[i] = the number of appearances of i in A. for i ← 2 to k C[i] ← C[i] + C[i-1] // C[i] = the number of elements in A that are ≤ i for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] - 1 return B
O(k)
O(n)
O(k)
O(n)
Total = O(n+k)
DS162-ps11

24. זמן ריצה -Counting sort
for i ← 1 to k C[i] ← = 0 for j ← 1 to n C[A[j]] ← C[A[j]] + 1 // C[i] = the number of appearances of i in A. for i ← 2 to k C[i] ← C[i] + C[i-1] // C[i] = the number of elements in A that are ≤ i for j ← n downto 1 B[C[A[j]]] ← A[j] C[A[j]] ← C[A[j]] - 1 return B
O(k)
O(n)
כמה זמן לקחו לנו מיוני ההשוואות?
O(k)
O(n)
Total = O(n+k)
DS162-ps11

25. שאלה 1: כמות איברים בטווח
נתונים n משתנים בטווח [1..k]. הציעו אלגוריתם שמבצע חישוב מקדים ב O(n+k), ולאחריו יודע להחזיר עבור כל a,b את כמות האיברים בטווח [a..b] בזמן O(1).
נזכיר לכם את מבני הנתונים: A 1 3 2 C 6 3 2 B
DS162-ps11

26. שאלה 1: כמות איברים בטווח
פתרון:
נשמור את מערך העזר C של Counting Sort.
C[i] = number of elements that are ≤i
נחזיר את C[b]-C[a-1]
Range(C,a,b)
return(C[b]-C[a-1])
end
DS162-ps11

27. Radix Sort זהו אלגוריתם מעטפת שמשתמש במיון אחר בתוכו.
נשתמש במיון יציב כלשהו, בדר"כ Counting sort
נמיין ע"פ ספרות במפתח. נתחיל באחדות ונתקדם משם.
d – כמות הספרות, b – הבסיס שבו מיוצג המפתח
Radix-Sort(A,d)
for i=1 to d
sort A on digit i with Counting-Sort
Running time: O(d(n+b))=O(n)
DS162-ps11

28. Radix Sort Example ⇒ ⇒ ⇒ Sort the following numbers using Radix
329, 457, 657, 839, 436, 720, 355
למה חשוב שהמיון המשני (זה של ספרה יחידה) יהיה יציב?
sorted by
digit 1
sorted by
digit 2 (and 1)
sorted ⇒ ⇒ ⇒
DS162-ps11

29. שאלה 2: מיון לקסיקוגרפי בהינתן n מילים באנגלית
נניח שהמילים כולם באותיות קטנות
המילים לא באותו האורך.
הציעו אלגוריתם למיון המילים לפי סדר לקסיקוגרפי בזמן 𝑂 𝑛 .
DS162-ps11

30. שאלה 2: מיון לקסיקוגרפי פתרון: רדוקציה (מילה חדשה):
נניח שיש לנו שתי בעיות 𝑃 1 , 𝑃 2 .
יש לנו אלגוריתם שפותר את 𝑃 2 .
רדוקציה מבעיה 𝑃 1 לבעיה 𝑃 2 זוהי דרך לפתור את הבעיה 𝑃 1 בעזרת האלגוריתם לפתרון 𝑃 2
DS162-ps11

31. שאלה 2: מיון לקסיקוגרפי Total run time is O(n). פתרון:
במקרה שלנו הרדוקציה היא מבעיית המיון הלקסיקוגרפי לבעית radix-sort.
הרדוקציה:
תרגום הקלט של 𝑃 1 להיות קלט של 𝑃 2 :
יהי m האורך של המילה המקסימלית בקלט. mהוא קבוע.
כל אות נייצג ע"י ספרה בבסיס 27. a=1,b=2,…z=26.סה"כ גודל הייצוג - 𝑂 𝑛𝑚 =𝑂 𝑛 .
למילים עם k<m אותיות נוסיף אפסים. זאת כדי שכולם יהיו באותו גודל.
נפתור את 𝑃 2 עם הקלט החדש:
בצע radix-sort כאשר 𝑑=𝑚, 𝑏=27.
זמן ריצה 𝑂 𝑛 .
תרגם את הפתרון של 𝑃 2 חזרה ל 𝑃 1
שנה את המספרים חזרה לאותיות
Total run time is O(n).
DS162-ps11

32. שאלה 2: מיון לקסיקוגרפי Lexicographical-sort input: {blue, red, green}
Radix-sort input:{(2,12,21,5,0),(18,5,4,0,0),(7,18,5,5,14)}
Radix-sort output:{(2,12,21,5,0),(7,8,5,5,14),(18,5,4,0,0)}
Lexicographical-sort output: {blue, green, red}

33. … Bucket Sort כל המפתחות מפוזרים באופן אחיד ב [0,1)
הרעיון הכללי – נחלק לn מקטעים (דליים) את כל המפתחות, ואז נאחד את המקטעים …
[0, 1 𝑛 )
[ 1 𝑛 , 2 𝑛 )
[ 2 𝑛 , 3 𝑛 )
[ 𝑛−1 𝑛 , 1 )

34. Bucket Sort נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
יהיו המספרים 21,55,44,73,86,34,86,92,18,8
0…9
10…19
20…29
30…39
40…49
50…59
60…69
70…79
80…89
90…99
DS162-ps11

35. Bucket Sort נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
יהיו המספרים 21,55,44,73,86,34,86,92,18,8 21
0…9
10…19
20…29
30…39
40…49
50…59
60…69
70…79
80…89
90…99
DS162-ps11

36. Bucket Sort נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
יהיו המספרים 21,55,44,73,86,34,86,92,18,8 55
0…9
10…19
20…29
30…39
40…49
50…59
60…69
70…79
80…89
90…99 21
DS162-ps11

37. Bucket Sort נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
יהיו המספרים 21,55,44,73,86,34,86,92,18,8 44
0…9
10…19
20…29
30…39
40…49
50…59
60…69
70…79
80…89
90…99 21 55
DS162-ps11

38. Bucket Sort נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
יהיו המספרים 21,55,44,73,86,34,86,92,18,8 73
0…9
10…19
20…29
30…39
40…49
50…59
60…69
70…79
80…89
90…99 21 44 55
DS162-ps11

39. Bucket Sort נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
יהיו המספרים 21,55,44,73,86,34,86,92,18,8 86
0…9
10…19
20…29
30…39
40…49
50…59
60…69
70…79
80…89
90…99 21 34 44 55 73 86
DS162-ps11

40. Bucket Sort נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
נחשוב על זה לרגע בעולם פשוט יותר 0…99 .
יהיו המספרים 21,55,44,73,86,34,86,92,18,8
0…9
10…19
20…29
30…39
40…49
50…59
60…69
70…79
80…89
90…99 18 21 34 44 55 73 86 92 8 86
DS162-ps11

41. Bucket Sort O(n) O(n) Total = O(n) Pseudo-code: n = length(A)
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
sort B[i] with insertion sort
Concatenate the lists in order
O(n)
O(n)
O(1)?
Total = O(n)
DS162-ps11

42. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1) /
[0.1,0.2) /
[0.2,0.3) /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8) /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

43. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.05 /
[0.1,0.2) /
[0.2,0.3) /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8) /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

44. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3) /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8) /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

45. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8) /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

46. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.07 /
0.05
[0.1,0.2)
0.12 /
[0.2,0.3)
מה זה מזכיר לנו?
0.29 /
[0.3,0.4) /
[0.4,0.5) /
Hash?
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8) /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

47. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.07
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21 /
0.29
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8) /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

48. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.06
0.07 /
0.05
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8) /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

49. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.06
0.07
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9) /
[0.9,1) /
DS162-ps11

50. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.06
0.07
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9) /
[0.9,1)
0.91 /
DS162-ps11

51. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.06
0.07
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9) /
[0.9,1)
0.94 /
0.91
DS162-ps11

52. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
𝐵 𝑛𝐴 𝑖 =𝐴[𝑖]
[0,0.1)
0.06
0.07
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9)
0.81 /
[0.9,1)
0.94 /
0.91
DS162-ps11

53. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
sort B[i] with
insertion sort
[0,0.1)
0.06
0.07
0.05 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9)
0.81 /
[0.9,1)
0.94 /
0.91
DS162-ps11

54. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
sort B[i] with
insertion sort
[0,0.1)
0.05
0.06
0.07 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9)
0.81 /
[0.9,1)
0.94 /
0.91
DS162-ps11

55. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
for i=1 to n
sort B[i] with
insertion sort
[0,0.1)
0.05
0.06
0.07 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9)
0.81 /
[0.9,1)
0.91 /
0.94
DS162-ps11

56. Bucket Sort Example
0.05, 0.12, 0.29, 0.07, 0.21, 0.06, 0.78, 0.91, 0.94, 0.81
Concatenate the lists in order
[0,0.1)
0.05
0.06
0.07 /
[0.1,0.2)
0.12 /
[0.2,0.3)
0.21
0.29 /
[0.3,0.4) /
[0.4,0.5) /
[0.5,0.6) /
[0.6,0.7) /
[0.7,0.8)
0.78 /
[0.8,0.9)
0.81 /
[0.9,1)
0.91 /
0.94
DS162-ps11

57. שאלה 3: שיפור מיון דליים
תכנן אלגוריתם למיון n מספרים בטווח [x,x+d) אשר:
רץ בזמן ממוצע 𝑂 𝑛 אם המספרים מתפלגים אחיד בטווח.
רץ בזמן 𝑂 𝑛 log 𝑛 במקרה של ההתפלגות גרועה ביותר.
DS162-ps11

58. שאלה 3: שיפור מיון דליים פתרון:
נשתמש באלגוריתם bucket sort המקורי בטווח 𝑥,𝑥+𝑑 וכאשר נמיין כל תא, נמיינו ע"י מיון merge sort.
ניתוח זמן ריצה
בהתפלגות טובה (אחידה), בכל התאים יהיה איבר אחד.
בהתפלגות הרעה, כל האיברים יהיו בתא אחד ונמיין זאת ב𝑂(𝑛 log⁡𝑛).
DS162-ps11

59. שאלה 3: שיפור מיון דליים פתרון נוסף
נשתמש באלגוריתם bucket sort המקורי בטווח 𝑥,𝑥+𝑑 עם השינויים הבאים:
האיברים בכל סל יסודרו בעץ AVL במקום ברשימה.
בחלק האחרון נשרשר את כל התאים לפי סדר inorder של העצים.
הערה: פונקצית החלוקה לתאים היא:
DS162-ps11

60. שאלה 3: שיפור מיון דליים
Time Complexity: Let ni be the number of elements in the tree in bucket i.
Inserting the n elements into the buckets takes O(n1logn1 + n2logn nnlognn)  When the keys are uniformly distributed ni = O(1) for every i, hence O(n1logn1 + n2logn nnlognn) ≤ c(n1 + n nn) = cn, where c is a constant. In the worst distribution cases: O(n1logn1 + n2logn nnlognn) ≤ O(n1logn + n2logn nnlogn) = O((n1 + n nn )(logn)) = O(nlogn)
Inorder traversals of all buckets takes O(n1 + n nn) = O(n)
Concatenation of all inorder traversal lists takes O(n)
The algorithm runs in O(n) time for uniformly distributed keys and runs in O(nlogn) in the worst distribution case.
DS162-ps11

61. שאלה 3: שיפור מיון דליים פתרון נוסף ומתחכם אבל עובד:
בצע במקביל את שני האלגוריתמים הבאים:
מיון bucket sort רגיל
כל מיון השוואות בזמן 𝑂 𝑛 log 𝑛 .
עצור כאשר אחד האלגוריתמים עוצר והחזר את האיברים ממויינים.
DS162-ps11

62. Review
DS162-ps11

63. שאלה 4: בחירת מיון יעיל ביותר
בהינתן מערך בגודל n של מספרים שלמים בטווח [1,n­3] הציעו אלגוריתם יעיל למיון האיברים.
מה עם מיון השוואות?
מה עם counting sort?
משהו אחר?
DS162-ps11

64. שאלה 4: בחירת מיון יעיל ביותר
פתרון:
מיון מבוסס השוואות:
זמן ריצה לוקח 𝑂 𝑛𝑙𝑜𝑔 𝑛 .
Counting sort:
k= n3 ⇒ O(n+ n3)=O(n3) .
Radix sort:
b=n, d =4, ⇒ O(d(b+n))=O( 4 (n+n))=O(n)
אפשר יותר טוב
אפילו גרוע יותר
הרבה יותר טוב
DS162-ps11

65. שאלה 4: בחירת מיון יעיל ביותר
לדוגמא, עבור 𝑛=2,
כל המספרים הם בטווח 1,2 3 =8
ומיוצגים ע"י 0001,0010,…,1000.
פתרון:
Radix sort:
b=n, d =4, ⇒ O(d(b+n))=O(4 (n+n))=O(n)
איך ולמה?
רעיון: לפני הפעלת radix sort ניצור קלט המתאים למיון.
המר את כל המספרים לבסיס 𝑛 , זה מתבצע בזמן 𝑂 𝑛 .
לצורך כך משתמשים בפונ' div,mod בצורה הבאה:
x = [x3,x2,x1,x0] (x0= x mod n, xi = 𝑥 𝑛 𝑖 mod n)
בצע מיון radix sort על הקלט החדש - 𝑂 𝑛 .
כל המספרים הם בטווח 1, 𝑛 3 . לכן, בבסיס החדש יש לכל היותר 4 ספרות לכל מספר.
סה"כ זמן ריצה האלגוריתם d=4, b=n ⇒ O(4(n+n))=O(n) .
DS162-ps11

66. שאלה 4: בחירת מיון יעיל ביותר
נתונות m קבוצות S1, S2,...,Sm. כל אחת מהקבוצות מכילה מספרים שלמים בטווח [1..n] ומתקיים כי 𝑚=𝑜 𝑛 .
ni = |Si| = number of elements in Si.
n1 + n nm = O(n)
הציעו אלגוריתם למיון כל הקבוצות S1, S2,...,Sm בסיבוכיות זמן ומקום של 𝑂 𝑛 .
הערה: הפלט הוא m קבוצות ממויינות ולא קבוצה אחת מאוחדת.
DS162-ps11

67. שאלה 4: בחירת מיון יעיל ביותר
רעיונות:
אלגוריתם נאיבי שימיין כל קבוצה ב𝑂 𝑛 log 𝑛 יביא לזמן ריצה של T(n) = O(n1logn1 + n2logn nmlognm) ≈O(nlogn).
אם נמיין כל קבוצה בנפרד ע"י counting sort: T(n) = O((n1+n) + (n2+n) (nm+n)) = O(n+mn) = O(n2). סיבוכיות מקום של 𝑂 𝑛 .
DS162-ps11

68. שאלה 4: בחירת מיון יעיל ביותר
רעיונות:
אלגוריתם נאיבי שימיין כל קבוצה ב𝑂 𝑛 log 𝑛 יביא לזמן ריצה של T(n) = O(n1logn1 + n2logn nmlognm) ≈O(nlogn).
אם נמיין כל קבוצה בנפרד ע"י counting sort: T(n) = O((n1+n) + (n2+n) (nm+n)) = O(n+mn) = O(n2). סיבוכיות מקום של 𝑂 𝑛 .
מה אתם אומרים על הרעיון מהתרגול הקודם של אלגוריתם יציב?
DS162-ps11

69. שאלה 4: בחירת מיון יעיל ביותר
פתרון מנצח:
צרף שדה חדש לכל איבר -set-num .
בנה מערך A עם כל האיברים מכל הקבוצות.
מיין את A בעזרת אלגוריתם 𝑐𝑜𝑢𝑛𝑡𝑖𝑛𝑔 𝑠𝑜𝑟𝑡.
פצל את המערך A ל k קבוצות לפי השדה שהוספנו - נעשה זאת ע"י counting sort לפי set-num
Total running time: O(n)
O(n)
O(n)
O(n)
O(n)
DS162-ps11

70. שאלה 5: מיון עם חריגים נתון מערך A עם מספרים חיוביים שלמים (רמז?)
כל המספרים פרט לעשרה הם בטווח [10,10n].
הציעו אלגוריתם למיון המערך A בזמן 𝑂 𝑛 במקרה הגרוע.
DS162-ps11

71. שאלה 5: מיון עם חריגים פתרון:
סרוק את המערך A והוצא את עשרת המספרים שאינם בטווח לתוך מערך B.
בצע counting sort על המערך A
בצע מיון השוואות כלשהו על B
מזג את A ו- B.
זמן ריצה- 𝑂(𝑛)
O(n)
O( (n-10) +10n)=O(n)
O(1)
O(n)
DS162-ps11

72. מה היה לנו פגשנו מיונים חדשים. המיונים היו תלויים בקלט.
המיונים היו בזמן לינארי.
שבוע הבא:
DS162-ps11