1. Data Structures: Sorts, CS, TAU 1 שמושים ביישומים רבים יש n רשומות, לכל רשומה מפתח: K 1, …..,K n רוצים לסדר את הרשומות כך שהמפתחות לא בסדר יורד (יתכנו כפולים) קריטריונים ליעילות: לא תמיד זהה מספר פעולות מספר השוואות בין מפתחות 2) מיון הכנסה Insertion Sort - איטרציה ה i דואגים שהאלמנטים [A[1],….,A[i נמצאים בסדר יחסי תקין (על ידי החלפות) 3) Selection Sort - בשלב ה i בוחרים את הקטן ביותר בין [A[i],…,A[n ושמים במקום ה i. שיטות פשוטות: 1) Bubble Sort - הקל צף כלפי מעלה 123456123456

2. Data Structures: Sorts, CS, TAU 2סיבוכיות ספירת פעולות כל האלגוריתמים: חסם עליון - חסם תחתון- O(N 2 )  (N 2 ) 2) Insertion - גם בשיטת החלפות לכן דומה ל Bubble ספירת החלפות - רלבנטי כשגודל הרשומה גדול 1) Bubble - - שתי רשומות [A[i], A[j, אם הן מסודרות יחסית - לא יתחלפו אחרת- יתחלפו בדיוק פעם אחת!! - ניקח שני סדרים: באחד K i,K j מסודרים ובשני אינם מסודרים L 1 = K 1,…,K n L 2 = K n,…,K 1 כל זוג יתחלף בממוצע בחצי מהפעמים - מספר הזוגות n(n-1)/2 מספר החלפות ממוצע n(n-1)/4

3. Data Structures: Sorts, CS, TAU 3 3) Selection Sort- - רוב העבודה בהשוואת מפתחות ולא בהחלפת רשומות. - מספר החלפות (O(N עצה שימושית: אם הרשומות כבדות: החזק פוינטרים לרשומות מיין פוינטרים לאחר מיון, הזז רשומות ב (O(N צעדים סיכום: - אלגוריתמים פשוטים : (  (n 2 ), O(n 2 - אלגוריתמים יעילים: (O(nlogn - נקודת חיתוך להחלטה: תלויה בהרבה גורמים- מאות - אלפים

4. Data Structures: Sorts, CS, TAU 4 QUICKSORT סבוכיות: ממוצע (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 רקורסיבית דוגמא לפיבוט: האיבר הגדול ביותר בין השניים השונים זה מזה משמאל

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

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

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

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

9. Data Structures: Sorts, CS, TAU 9 סימון : (T(n זמן מיון מערך בגודל n. הסתברויות : ראשון הוא i + 1st שני קטן מ i + 1 החלף בין בני הזוג

10. Data Structures: Sorts, CS, TAU 10 נניח : נוכיח ( באינדוקציה ): אם C=4C 2

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

12. Data Structures: Sorts, CS, TAU 12 HEAPSORT תזכורת : ב HEAP כל צומת קטן מבניו HEAP הוא מאוזן אם כל העלים כמעט באותה שכבה. 2 511 691416 7 81215 פעולות : INSERT DELETEMIN יצוג במערך : 1152149687161512 3216549871110 i 2i+1 2i2i

13. Data Structures: Sorts, CS, TAU 13 עקרון ה HEAPSORT 1) For X on list L do 2) INSERT(X,heap); 3) While not EMPTY(heap) do 4) y:=DELETEMIN(heap); 5) Print(y); 6) end; O(nlogn) אם לא רוצים הדפסה - ניתן לשמור במערך : כשמשמיטים איבר מ [A[1],…,A[i אזי [A[i מתפנה ==> הכנס בו את המושמט ==> תקבל בסוף איברים בסדר יורד והתוכנית היא : For i = n to 2 do SWAP(A[i],A[1]) PUSHDOWN(A[1])

14. Data Structures: Sorts, CS, TAU 14 דוגמה : 3479811 3 47 98 Swap(11,3)Pushdown(11) 11 47 983 4 87 9 3 Swap(11,4) 11 87 943 Pushdown(11) 7 811 943

15. Data Structures: Sorts, CS, TAU 15 Swap(9,7) 9 811 743 Pushdown(9) 8 911 743 98 743 לבסוף נקבל : 1198743 עוד n/2 החלפות ==> סדר עולה ! עד כאן : מעבר ממערך HEAP- י למערך ממוין

16. Data Structures: Sorts, CS, TAU 16 להשלמת התמונה של מיון מערך שרירותי צריך : העבר מערך למערך HEAP- י. דרך : החל מהשורה הלפני האחרונה בצע (Pushdown(i כלומר : דאג שתת העץ מתחת ל -i יהיה לגיטימי אנליזה : 1 ) בנית HEAP n/2 איטרציות - כ ” א לכל היותר logn ==> (O(nlogn למעשה : שנותן (O(n 2 ) ביצוע ה sort: n פעולות - כ ” א logn ==> (O(logn

17. Data Structures: Sorts, CS, TAU 17 הערות : 1) O(nlogn) :HEAP ב worstcase 2 ) ממוצע : קצת יותר גרוע מ QUICKSORT 3 ) אם רוצים רק את k הקטנים ביותר ממוינים : (O(n+klogn כניסה מיין k קטנים

18. Data Structures: Sorts, CS, TAU 18 MERGESORT עובד על ידי מיזוג רשימות מזג רשימות באורך 1 ==> רשימה באורך 2 2 ==> 4 4 ==> 8 n <== n/2 כל מיזוג לינארי ==> (O(nlogn (Cormen 13-15)

19. Data Structures: Sorts, CS, TAU 19 BIN SORTING מיונים שראינו עד כה : (O(nlogn האם אפשר לבצע בפחות מ (O(nlogn? בקרוב : (  (nlogn אם לא יודעים כלום על המספרים בשלב זה : אם יודעים - אפשר לרדת דוגמה 1: אם יודעים שבמערך [A[1,…,n נמצאים המפתחות n,….,1 אזי מיון לתוך B ב (O(n: B[A[i].key] = A[i] דוגמה 2: Count Sort מערך [A[1],…,A[n, איברים 1,…,k כל איבר מופיע מספר פעמים : 3 2 3 1 4 2 2 5 מיון המערך ע ” י : 1. ספירת האיברים מכל סוג 2. כתיבתם במערך תוצאה פרטים : Cormen 175-177

20. Data Structures: Sorts, CS, TAU 20 דוגמה 3: בתנאים של דוגמה 1, מיון בתוך A: אם A[i].key = j החלף [A[i עם [A[j From i = 1 to n do while A[i].key <> i do swap(A[i], A[A[i].key]) פעולות :(O(n צעדים (O(n החלפות ( איבר שנחת במקומו לא יוחלף יותר !) BIN SORTING הינו מיון האיברים לתוך תאים (BINS) ולבסוף - שרשור התאים - דוגמה 1 היא BIN-SORT פשוט גודל BIN קבוע ( 1) במקרה הכללי גודל משתנה פעולות שנרצה : א ) הכנס איבר לתוך BIN ב ) חבר שני BIN- ים

21. Data Structures: Sorts, CS, TAU 21 פתרון : 1) כל BIN רשימה מקושרת 2) HEADERS מצביעים על תחילת הרשומה H1 E1 H2 E2 הכנסה : (O(1 שרשור : (O(1 כעת ניתן לשרשר מספר שרירותי של רשימות לתוך n סלים

22. Data Structures: Sorts, CS, TAU 22 אנליזה : m - מספר הערכים האפשריים ( מספר הסלים ) n - מספר המפתחות סיבוכיות הכנסות = (O(n סיבוכיות שרשורים = (O(m O(m+n) אם מספר המפתחות גדול ממספר הסלים (m < n) O(n) אם מספר המפתחות קטן ממספר הסלים (m > n) למשל m = n 2 O(n 2 ) דוגמה : מיין את המספרים i 2 כאשר i=1,2,..,10 כלומר מיין את 100,....,0,1,4

23. Data Structures: Sorts, CS, TAU 23 פתרון : - הכן n סלים - מיין לפי הספרה הפחות משמעותית - מיין לפי הספרה היותר משמעותית Bin 0 1 2 3 4 5 6 7 8 9 איברים 0 1, 81 - 64, 4 25 36, 16 - 9, 49 Bin 0 1 2 3 4 5 6 7 8 9 איברים 0, 1, 4, 9 16 25 36 49 - 64 - 81 - 0, 1, 81, 64, 4, 25, 36, 16, 9, 49 שרשור

24. Data Structures: Sorts, CS, TAU 24 למה עובד ? נניח :i = 10a + b, j = 10c + d נניח :i < j ==> ברור ש - אם a < c אזי שלב שני ישים בסלים המתאימים, והמיון תקין. למה טוב BIN SORT? - תחומים שידועה עליהם אינפורמציה כמו 1,…,n k ( קבוע k) - מחרוזת באורך k - אם a = c אזי b < d ולכן : מיון ראשון ימיין בסדר לכן i יכנס לסל לפני j בשלב השני

25. Data Structures: Sorts, CS, TAU 25 האם תמיד טוב ? לא אם k מאוד גדול !! דוגמה : n = 100, k = 100 nk :BIN SORT (100 מחזורים של 100 פעולות ) מיון אחר : nlogn ו - nk > nlogn אבל … זהירות בהשוואות ! במיון רגיל - השוואה = (O(k ולכן יש חשיבות למודל החישובי !!!

26. Data Structures: Sorts, CS, TAU 26 RADIX SORT - נתונים k מפתחות f 1,…,f k - רוצים למיין בסדר לכסיקוגרפי כלומר : (a 1,…,a k ) < (b 1,…,b k ) אמ ” ם : 1) a 1 < b 1 2) או a 1 = b 1, a 2 < b 2 a 1 = b 1,…., a k-1 = b k-1, a k = b k (k דומה ל BIN SORT מוכלל, רק צריך לכל סוג מפתחות את תחום הסלים שלו.

27. Data Structures: Sorts, CS, TAU 27 חסם תחתון למיון בהשוואות - מיונים בהשוואה : (  (nlogn - מיונים בהשמות : (  (n סיבה : בהשוואה התוצאה היא בינארית ( כן / לא ) בהשמה התוצאה עם יותר אפשרויות. האם ניתן להשתמש בהשמה לכל מיון ? לא למיון תחומים בלתי מוגבלים ( דוגמה : השלמים ) בניית החסם התחתון : עץ החלטה : - כל צומת מייצג את מרחב האפשרויות - בביצוע השוואה המרחב מתחלק לשניים, לפי התוצאה. דוגמה : Insertion Sort 1 ) מיין האיברים [A[1], A[2 2 ) מיין את [A[1], A[2], A[3 abcabc A[1] A[2] A[3]

28. Data Structures: Sorts, CS, TAU 28 abc acb bac bca cab cba 1 bac bca cba abc acb cab 23 כןלא A[2]<A[1]? (b<a?) bca cba bacacb cab abc 4567 A[3]<A[2]? (c<a?) A[3]<A[2]? cbabcacabacb 891011 A[2]<A[1]?

29. Data Structures: Sorts, CS, TAU 29 חסם תחתון : עבור מיון שרירותי שתתנו לי, אראה לכם מקרה שייקח כמו החסם התחתון. - כל מיון שתבחרו יגדיר עץ. - אבחר את המסלול בעץ. - עץ הוא בינארי : אם בעץ k עלים, אזי קיים מסלול שאורכו לפחות logk!! ( עץ בינארי מלא ומאוזן ==> בוודאי logk, אם לא מלא ==> פחות עלים !!) - העלים מייצגים סדרים בסיסיים ואת כולם ! - מספר הסדרים הוא !n. לכן אורך המסלול המקסימלי (!log(n

30. Data Structures: Sorts, CS, TAU 30 חסם תחתון לזמן ממוצע - אפשר להראות שגם הוא (W(nlogn - צורת ההוכחה : להראות שעץ בינארי k עלים - עומק מסלול ממוצע logk. הוכחה בשלילה : יהי T הקטן ביותר כך שלא מתקיים. אז ל T בן אחד או שניים : א ) אם בן בודד ==> סתירה לקטן ביותר n 1n1n עומק ממוצע קטן מ logk k עלים 1n1n2n2n n ב ) אם שני בנים : מספר העלים בהם הוא k 1 ו - k 2 k 1 <kk-k 1 =k 2

31. Data Structures: Sorts, CS, TAU 31 אזי ממוצע אורך מסלולים לעלים ב T הוא : - מציאת חסם תחתון לביטוי, ע ” י מציאת מינימום שלו ( תחת אילוץ k 1 +k 2 =k) פתרון התרגיל נותן מינימום ב k 1 =k 2 ==>

32. Data Structures: Sorts, CS, TAU 32 סטטיסטיקת סדר ומציאת חציון Order - Statistics and Median ith order statistic: האיבר ה i בגודלו. בעיה: נתונים n איברים, מצא את האיבר ה i בגודלו. דוגמה: 1) מצא מקסימום 2) מצא חציון (Median) - האיבר האמצעי בקבוצה. 1) מציאת מקסימום: max  A[1] for i  2 to length(A) do if max < A[i] do if max < A[i] then max  A[i] return max סיבוכיות (O(n

33. Data Structures: Sorts, CS, TAU 33 2) מציאת מינימום: כנ ” ל (O(n 3) מציאת מינימום ומקסימום: צורה פשטנית השוואות צורה פשטנית השוואות תחכום דורש רקהשוואות: תחכום דורש רקהשוואות: - קח זוג נתונים מהקלט: a,b - השווה a ל- b - השווה הגדול ל max - השווה הקטן ל min רק 3 פעולות לשני איברים 4) מציאת שני בגודלו: פעולות 4) מציאת k בגודלו: פעולות שכלול: בצע על HEAP דורש:

34. Data Structures: Sorts, CS, TAU 34 2) מציאת חציון: הקשה ביותר בין סטאטיסטיקות הסדר בשיעור זה: חציון וכל סטאטיסטיק (O(n א) מציאה אקראית בזמן ממוצע (O(n בצע partition אקראי חפש בצד הנכון 1) סיבוכיות O(n 2 ) :worst case כי איטרציה 1: n איברים 2: n-1 איברים וכו ’ 2: n-1 איברים וכו ’ 2) סיבוכיות ממוצעת: (גודל צד שמאל של החלוקה מתפלג אחיד בין 1 ל n)

35. Data Structures: Sorts, CS, TAU 35 נניח אינדוקטיבית: נוכיח: (כי אפשר לבחור c גדול מספיק)

36. Data Structures: Sorts, CS, TAU 36 א) מציאת statistic ב- O(n) worst case: בחר אלמנט i מתוך n איברים: (select) 1) חלק האיברים ל n/5 קבוצות של 5 איברים 2) מצא את החציון של כ ” א מהקבוצות (מיון פשוט) 3) השתמש רקורסיבית ב select למציאת החציון של החציונים 4) בצע partition מסביב לחציון החציונים יהי k מספר האיברים בחלק הנמוך יהי n-k מספר האיברים בחלק הגבוה 5) השתמש ב select רקורסיבית למציאת i בחלק הנמוך או i-k בחלק הגבוה

37. Data Structures: Sorts, CS, TAU 37 x 3n/10 גדולים קטנים חציון החציונים אנליזה: רקורסיהחציון החציונים סכום השברים קטן מ 1  (O(n

38. Data Structures: Sorts, CS, TAU 38 הוכחה: (ניתן לבחור c גדול מספיק כך ש (c(n/10-7 גדול מהפונקציה המתוארת ע ” י (O(n