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

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

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

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

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

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 09.12.2018

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

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

זמן ריצה -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 09.12.2018

זמן ריצה -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 09.12.2018

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

שאלה 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 09.12.2018

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 09.12.2018

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 329 457 657 839 436 720 355 720 355 436 457 657 329 839 720 355 436 457 657 329 839 720 329 436 839 355 457 657 720 329 436 839 355 457 657 329 355 436 457 657 720 839 ⇒ ⇒ ⇒ DS162-ps11 09.12.2018

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

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

שאלה 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 09.12.2018

שאלה 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}

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

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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 09.12.2018

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

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

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

שאלה 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 + n2logn2 + ... + nnlognn)  When the keys are uniformly distributed ni = O(1) for every i, hence O(n1logn1 + n2logn2 + ... + nnlognn) ≤ c(n1 + n2 + ... + nn) = cn, where c is a constant. In the worst distribution cases: O(n1logn1 + n2logn2 + ... + nnlognn) ≤ O(n1logn + n2logn + ... + nnlogn) = O((n1 + n2 + ... + nn )(logn)) = O(nlogn) Inorder traversals of all buckets takes O(n1 + n2 + ... + 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 09.12.2018

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

Review DS162-ps11 09.12.2018

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

שאלה 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 09.12.2018

שאלה 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 09.12.2018

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

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

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

שאלה 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 09.12.2018

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

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

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