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

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

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

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

5. Counting-Sort רעיון האלגוריתם:
נספור כמה פעמים מופיע כל אחד מהאיברים.
לפי הספירה נדע איך לסדר את האיברים.
המיון הינו יעיל אך הקבועים שלו גדולים. (עוד מערכים וכו')
DS182-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
DS182-ps11

7. Counting-Sort for i ← 1 to k C[i] ← = 0 A 1 3 2 C DS182-ps11
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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)
DS182-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)
DS182-ps11

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

29. 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 ⇒ ⇒ ⇒
DS182-ps11

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

31. שאלה 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}
DS182-ps11

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

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

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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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)
DS182-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) /
DS182-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) /
DS182-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) /
DS182-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) /
DS182-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) /
DS182-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) /
DS182-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) /
DS182-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) /
DS182-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 /
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-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
DS182-ps11

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

58. שאלה 3 (a): בחירת מיון יעיל ביותר
פתרון:
מיון מבוסס השוואות:
זמן ריצה לוקח 𝑂 𝑛𝑙𝑜𝑔 𝑛 .
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)
אפשר יותר טוב
אפילו גרוע יותר
הרבה יותר טוב
DS182-ps11

59. שאלה 3 (a): בחירת מיון יעיל ביותר
הסבר על מעבר בסיסים:
המר מספר 𝑥 לבסיס 𝑘
לצורך כך משתמשים בפונ' div,mod בצורה הבאה:
𝑥=[ 𝑥 log 𝑘 𝑛 ,…, 𝑥 1 , 𝑥 0 ] ( 𝑥 0 =𝑥 𝑚𝑜𝑑 𝑘,xi = 𝑥 𝑘 𝑖 mod k)
ניתן לכתוב את המספר 𝑥 בצורה הבאה
𝑥= 𝑖=0 log 𝑘 𝑥 𝑥 𝑖 𝑘 𝑖 = 𝑥 log 𝑘 𝑥 𝑘 log 𝑘 𝑛 +…+ 𝑥 1 𝑘+ 𝑥 0
DS182-ps11

60. שאלה 3 (a): בחירת מיון יעיל ביותר
לדוגמא, עבור 𝑛=2,
כל המספרים הם בטווח 1,2 3 =8
עובר 𝑥=7 נקבל 𝑥 𝑖 = 𝑖 𝑚𝑜𝑑 2
𝑥 0 = 7 𝑚𝑜𝑑 2=1
𝑥 1 = 𝑚𝑜𝑑 2=1
𝑥 2 = 𝑚𝑜𝑑 2=1
𝑥 3 = 𝑚𝑜𝑑 2=0
7= 1∙ ∙2 1 +1∙ ∙ 2 3
DS182-ps11

61. שאלה 3 (a): בחירת מיון יעיל ביותר
פתרון:
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) .
DS182-ps11

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

63. שאלה 3 (b): בחירת מיון יעיל ביותר
רעיונות:
אלגוריתם נאיבי שימיין כל קבוצה ב𝑂 𝑛 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). סיבוכיות מקום של 𝑂 𝑛 .
DS182-ps11

64. שאלה 3 (b) : בחירת מיון יעיל ביותר
רעיונות:
אלגוריתם נאיבי שימיין כל קבוצה ב𝑂 𝑛 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). סיבוכיות מקום של 𝑂 𝑛 .
DS182-ps11

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

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

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

68. שאלה 4: שיפור מיון דליים
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.
DS182-ps11

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

70. Review
DS182-ps11

71. Review
DS182-ps11

72. Review
DS182-ps11

73. Review
DS182-ps11

74. Review
DS182-ps11

75. Review
DS182-ps11

76. Review
DS182-ps11

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

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

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