1. 1 שמושים ביישומים רבים יש n רשומות, לכל רשומה מפתח: K 1,…..,K n רוצים לסדר את הרשומות כך שהמפתחות לא בסדר יורד (יתכנו כפולים) קריטריונים ליעילות: לא תמיד זהה מספר פעולות מספר השוואות בין מפתחות מיונים (SORTS)

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

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

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

5. 5 סבוכיות: ממוצע (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 רקורסיבית דוגמא לפיבוט: האיבר הגדול ביותר בין השניים השונים זה מזה משמאל

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

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

8. 8 ג) Worst Case אם כל פעם נבחר לפיבוט את הגדול ביותר אז המערך בגודל n יתחלק למערך של 1 + מערך של n -1 n n - 1 n - 2 2 n - 1 סכום העבודה בכל הרמות (עבודה לינארית באלמנטים) = סכום העומקים = n - 1 + (1 + 2 + …… + n - 1) = O(n 2 ) = Hanoch: done 22/12/03

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

10. 10 סימון: (T(n זמן מיון מערך בגודל n. הסתברויות: ראשון הוא i + 1st שני קטן מ i + 1 החלף בין בני הזוג

11. 11 נניח : נוכיח ( באינדוקציה ): אם C=4C 2

12. 12 QuickSort- המהיר ביותר בממוצע מכל אלגוריתמי ה nlogn זרוז האלגוריתם: נוכל לדאוג שהפיבוט יהיה מרכזי יותר. דוגמה: האמצעי מבין שלושה אלמנטים דוגמה: קח k אלמנטים ובחר אמצעי TradeOff : k קטן  חוסר איזון k גדול  מציאת אמצעי יקרה החלטה על סיום האלגוריתם: - אנחנו סיימנו ב n = 2 - עבור n קטן לא אכפת לנו שהסיבוכיות תהיה (O(n 2 - Knuth ממליץ על n = 9 שימוש בפוינטרים לרשומות: - חוסך העתקות - עולה במצביעים הערות ושיפורים hlevi: Done class2 1/1/03 hlevi: Done class2 1/1/03

13. 13 תזכורת: ב HEAP כל צומת קטן מבניו HEAP הוא מאוזן אם כל העלים כמעט באותה שכבה. 2 511 691416 7 81215 פעולות: INSERT DELETEMIN ייצוג במערך: 1152149687161512 3216549871110 i 2i+1 2i2i HEAPSORT hlevi: Done class2 1/1/03 hlevi: Done class2 1/1/03

14. 14 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]) עקרון ה-HEAPSORT

15. 15 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 דוגמה

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

17. 17 להשלמת התמונה של מיון מערך שרירותי צריך: העבר מערך למערך HEAP-י. דרך: החל מהשורה הלפני האחרונה בצע (Pushdown(i כלומר: דאג שתת העץ מתחת ל-i יהיה לגיטימי אנליזה: 1) בנית HEAP n/2 איטרציות- כ”א לכל היותר logn  O(nlogn) למעשה: שנותן (O(n 2) ביצוע ה sort: n פעולות- כל-אחת logn  O(nlogn)

18. 18 הערות: 1) O(nlogn) :HEAP ב worstcase 2) ממוצע: קצת יותר גרוע מ QUICKSORT 3) אם רוצים רק את k הקטנים ביותר ממוינים: O(n+klogn) כניסה מיין k קטנים hlevi: Done c2 1/01/03 hlevi: Done c2 1/01/03

19. 19 עובד על ידי מיזוג רשימות מזג רשימות באורך 1  רשימה באורך 2 2  4 4  8 n  n/2 כל מיזוג לינארי  O(nlogn) (Cormen 13-15) MERGESORT

20. 20 מיונים שראינו עד כה: (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 BIN SORTING

21. 21 בתנאים של דוגמה 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-ים דוגמה 3

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

23. 23 אנליזה: 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 hlevi: Need to cover class 1 hlevi: Need to cover class 1

24. 24 פתרון: - הכן 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 שרשור hlevi: Need class1 hlevi: Need class1

25. 25 למה עובד? נניח:i = 10a + b, j = 10c + d נניח:i < j  ברור ש - אם a < c אזי שלב שני ישים בסלים המתאימים, והמיון תקין. למה טוב BIN SORT? - תחומים שידועה עליהם אינפורמציה כמו 1,…,n k (קבוע k) - מחרוזת באורך k - אם a = c אזי b < d ולכן: מיון ראשון ימיין בסדר לכן i יכנס לסל לפני j בשלב השני b hlevi: Need class1 hlevi: Need class1

26. 26 האם תמיד טוב? לא אם k מאוד גדול!! דוגמה: n = 100, k = 100 nk :BIN SORT (100 מחזורים של 100 פעולות) מיון אחר: nlogn ו- nk > nlogn אבל… זהירות בהשוואות! במיון רגיל- השוואה = (O(k ולכן יש חשיבות למודל החישובי!!! hlevi: Need c1 hlevi: Need c1

27. 27 - נתונים 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 מוכלל, רק צריך לכל סוג מפתחות את תחום הסלים שלו. RADIX SORT hlevi: Need c1 hlevi: Need c1

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

29. 29 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]?

30. 30 - מספר הסדרים הוא !n. לכן אורך המסלול המקסימלי (!log(n חסם תחתון: עבור מיון שרירותי שתתנו לי, אראה לכם מקרה שייקח כמו החסם התחתון. - כל מיון שתבחרו יגדיר עץ. - אבחר את המסלול בעץ. - עץ הוא בינארי: אם בעץ k עלים, אזי קיים מסלול שאורכו לפחות logk!! (עץ בינארי מלא ומאוזן  בוודאי logk, אם לא מלא  פחות עלים!!) - העלים מייצגים סדרים בסיסיים ואת כולם!

31. 31 - אפשר להראות שגם הוא (  (nlogn - צורת ההוכחה: להראות שעץ בינארי k עלים - עומק מסלול ממוצע logk. הוכחה בשלילה: יהי T הקטן ביותר כך שלא מתקיים. אז ל T בן אחד או שניים: א) אם בן בודד  סתירה לקטן ביותר n 1n1n עומק ממוצע קטן מ logk k עלים 1n1n2n2n n ב) אם שני בנים: מספר העלים בהם הוא k 1 ו- k 2 k 1 <kk-k 1 =k 2 חסם תחתון לזמן ממוצע

32. 32 אזי ממוצע אורך מסלולים לעלים ב T הוא: - מציאת חסם תחתון לביטוי, ע”י מציאת מינימום שלו (תחת אילוץ k 1 +k 2 =k) פתרון התרגיל נותן מינימום ב k 1 =k 2  hlevi: donec1 hlevi: donec1

33. 33 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] then max  A[i] return max סיבוכיות (O(n סטטיסטיקת סדר ומציאת חציון

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

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

36. 36 נניח אינדוקטיבית: נוכיח: (כי אפשר לבחור c גדול מספיק)

37. 37 א) מציאת 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 בחלק הגבוה

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

39. 39 הוכחה: (ניתן לבחור c גדול מספיק כך ש (c(n/10-7 גדול מהפונקציה המתוארת ע”י (O(n תוצאה: ניתן לבצע quick sort ב – O(nlogn) worst case !!