1. תרגול 11
מיון בזמן ליניארי
מבני נתונים 152 תרגול 11

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

3. Counting-Sort רעיון האלגוריתם: נספור כמה פעמים מופיע כל אחד מהאיברים.
לפי הספירה נדע איך לסדר את האיברים.
מבני נתונים 152 תרגול 11

4. 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
מבני נתונים 152 תרגול 11

5. Counting-Sort for i ← 1 to k C[i] ← = 0 A 1 3 2 C
מבני נתונים 152 תרגול 11

6. 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
מבני נתונים 152 תרגול 11

7. 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
מבני נתונים 152 תרגול 11

8. 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
מבני נתונים 152 תרגול 11

9. 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
מבני נתונים 152 תרגול 11

10. 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
מבני נתונים 152 תרגול 11

11. 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
מבני נתונים 152 תרגול 11

12. 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
מבני נתונים 152 תרגול 11

13. 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
מבני נתונים 152 תרגול 11

14. 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
מבני נתונים 152 תרגול 11

15. 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
מבני נתונים 152 תרגול 11

16. 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
מבני נתונים 152 תרגול 11

17. 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
מבני נתונים 152 תרגול 11

18. 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
מבני נתונים 152 תרגול 11

19. 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
מבני נתונים 152 תרגול 11

20. מה נעשה אם הטווח מכיל גם מספרים שליליים, לדוגמה [-k,k] ?
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
מה נעשה אם הטווח מכיל גם מספרים שליליים, לדוגמה [-k,k] ? A 1 3 2 C 3 2 B 3 2 1
מבני נתונים 152 תרגול 11

21. זמן ריצה -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)
מבני נתונים 152 תרגול 11

22. Question 1: Size of ranges using Counting-Sort
נתונים n משתנים בטווח [1..k]. הציעו אלגוריתם שמבצע חישוב מקדים בזמן O(n+k), ולאחריו יודע להחזיר עבור כל a,b את כמות האיברים בטווח [a..b] בזמן O(1).
מבני נתונים 152 תרגול 11

23. Question 1: Size of ranges using Counting-Sort
פתרון:
נשמור את מערך העזר 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])
מבני נתונים 152 תרגול 11

24. 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)
מבני נתונים 152 תרגול 11

25. (זה של ספרה יחידה) יהיה יציב?
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 ⇒ ⇒ ⇒
מבני נתונים 152 תרגול 11

26. Question 5: Sorting lexicographically
נניח שהמילים כולן באותיות קטנות
המילים לא באותו האורך.
הציעו אלגוריתם למיון המילים לפי סדר לקסיקוגרפי בזמן 𝑂 𝑛 .
מבני נתונים 152 תרגול 11

27. Question 5: Sorting lexicographically
פתרון:
רדוקציה:
נניח שיש לנו שתי בעיות 𝑃 1 , 𝑃 2 .
יש לנו אלגוריתם שפותר את 𝑃 2 .
רדוקציה מבעיה 𝑃 1 לבעיה 𝑃 2 זוהי דרך לפתור את הבעיה 𝑃 1 בעזרת האלגוריתם לפתרון 𝑃 2
מבני נתונים 152 תרגול 11

28. Question 5: Sorting lexicographically
פתרון:
במקרה שלנו הרדוקציה היא מבעיית המיון הלקסיקוגרפי לבעית 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).
מבני נתונים 152 תרגול 11

29. Question 5: Sorting lexicographically
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}
מבני נתונים 152 תרגול 11

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

31. 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
מבני נתונים 152 תרגול 11

32. 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
מבני נתונים 152 תרגול 11

33. 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
מבני נתונים 152 תרגול 11

34. 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
מבני נתונים 152 תרגול 11

35. 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
מבני נתונים 152 תרגול 11

36. 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
מבני נתונים 152 תרגול 11

37. 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
מבני נתונים 152 תרגול 11

38. 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)
מבני נתונים 152 תרגול 11

39. 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) /
מבני נתונים 152 תרגול 11

40. 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) /
מבני נתונים 152 תרגול 11

41. 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) /
מבני נתונים 152 תרגול 11

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.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) /
מבני נתונים 152 תרגול 11

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.07 /
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) /
מבני נתונים 152 תרגול 11

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.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) /
מבני נתונים 152 תרגול 11

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.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) /
מבני נתונים 152 תרגול 11

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.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) /
מבני נתונים 152 תרגול 11

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.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 /
מבני נתונים 152 תרגול 11

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.78 /
[0.8,0.9) /
[0.9,1)
0.94 /
0.91
מבני נתונים 152 תרגול 11

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.81 /
[0.9,1)
0.94 /
0.91
מבני נתונים 152 תרגול 11

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
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
מבני נתונים 152 תרגול 11

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
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
מבני נתונים 152 תרגול 11

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
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
מבני נתונים 152 תרגול 11

53. 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
מבני נתונים 152 תרגול 11

54. Question 2 : An improved Bucket-Sort algorithm
תכנן אלגוריתם למיון n מספרים בטווח [x,x+d) אשר:
רץ בזמן ממוצע 𝑂 𝑛 אם המספרים מתפלגים אחיד בטווח.
רץ בזמן 𝑂 𝑛 log 𝑛 במקרה של ההתפלגות גרועה ביותר.
מבני נתונים 152 תרגול 11

55. Question 2 : An improved Bucket-Sort algorithm
פתרון:
נשתמש באלגוריתם bucket sort המקורי בטווח 𝑥,𝑥+𝑑 𝑥,𝑥+𝑑 וכאשר נמיין כל תא, נמיינו ע"י מיון merge sort.
ניתוח זמן ריצה
בהתפלגות טובה (אחידה), בכל התאים יהיה איבר אחד.
בהתפלגות הרעה, כל האיברים יהיו בתא אחד ונמיין זאת ב𝑂(𝑛 log⁡𝑛).
מבני נתונים 152 תרגול 11

56. Question 2 : An improved Bucket-Sort algorithm
פתרון נוסף:
נשתמש באלגוריתם bucket sort המקורי בטווח 𝑥,𝑥+𝑑 עם השינויים הבאים:
האיברים בכל דלי יסודרו בעץ AVL במקום ברשימה.
בחלק האחרון נשרשר את כל התאים לפי סדר inorder של העצים.
הערה: פונקצית החלוקה לתאים היא:
מבני נתונים 152 תרגול 11

57. Question 2 : An improved Bucket-Sort algorithm
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.
מבני נתונים 152 תרגול 11

58. Question 2 : An improved Bucket-Sort algorithm
פתרון נוסף:
בצע במקביל את שני האלגוריתמים הבאים:
מיון bucket sort רגיל
כל מיון השוואות בזמן 𝑂 𝑛 log 𝑛 .
עצור כאשר אחד האלגוריתמים עוצר והחזר את האיברים ממויינים.
מבני נתונים 152 תרגול 11

59. Review
מבני נתונים 152 תרגול 11

60. Question 3: Choosing sorting algorithm efficiently
בהינתן מערך בגודל n של מספרים שלמים בטווח [1,n­3] הציעו אלגוריתם יעיל למיון האיברים.
מה עם מיון השוואות?
מה עם counting sort?
משהו אחר?
מבני נתונים 152 תרגול 11

61. Question 3: Choosing sorting algorithm efficiently
מיון מבוסס השוואות:
זמן ריצה 𝑂 𝑛𝑙𝑜𝑔 𝑛 .
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)
אפשר יותר טוב
אפילו גרוע יותר 
מבני נתונים 152 תרגול 11

62. Question 3: Choosing sorting algorithm efficiently
פתרון:
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 ספרות לכל מספר. נניח 𝑛=2 אז המספרים בטווח 1 עד 8 מיוצגים ע"י 0001,0010,…,1000.
סה"כ זמן ריצה האלגוריתם d=4, b=n ⇒ O(4(n+n))=O(n) .
מבני נתונים 152 תרגול 11

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

64. Question 4: Sorting a collection of sets efficiently
פתרונות נאיביים לא עובדים:
אם נמיין כל קבוצה ב𝑂 𝑛 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). סיבוכיות מקום של 𝑂 𝑛 .
מבני נתונים 152 תרגול 11

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

66. Question 6: Sorting input with anomalies
מבני נתונים 152 תרגול 11

67. Question 6: Sorting input with anomalies
פתרון:
סרוק את המערך A והוצא את עשרת המספרים שאינם בטווח לתוך מערך B.
בצע counting sort על המערך A
בצע מיון השוואות כלשהו על B
מזג את A ו- B.
סה"כ זמן ריצה- 𝑂(𝑛)
O(n)
O( (n-10) +10n)=O(n)
O(1)
O(n)
מבני נתונים 152 תרגול 11