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

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

סיבוכיות ספירת פעולות כל האלגוריתמים: חסם עליון - חסם תחתון- O(N2) ספירת החלפות - רלבנטי כשגודל הרשומה גדול 1) Bubble - שתי רשומות [A[i], A[j , אם הן מסודרות יחסית - לא יתחלפו אחרת- יתחלפו בדיוק פעם אחת!! - ניקח שני סדרים: L1 = K1,…,Kn L2 = Kn,…,K1 באחד Ki,Kj מסודרים ובשני אינם מסודרים כל זוג יתחלף בממוצע בחצי מהפעמים - מספר הזוגות n(n-1)/2 מספר החלפות ממוצע n(n-1)/4 2) Insertion- גם בשיטת החלפות לכן דומה ל Bubble

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

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

האלגוריתם האלגוריתם מורכב מ: 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) בדיקה!!!!

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

ג) Worst Case אם כל פעם נבחר לפיבוט את הגדול ביותר אז המערך בגודל n יתחלק למערך של 1 + מערך של n -1 n n - 1 n - 2 2 סכום העבודה בכל הרמות (עבודה לינארית באלמנטים) = סכום העומקים = n - 1 + (1 + 2 + …… + n - 1) = O(n2) =

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

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

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

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

HEAPSORT תזכורת: ב HEAP כל צומת קטן מבניו 2 5 11 6 9 14 16 7 8 12 15 פעולות: INSERT DELETEMIN ייצוג במערך: 11 5 2 14 9 6 8 7 16 15 12 3 1 4 10 i 2i+1 2i

עקרון ה-HEAPSORT O(nlogn) O(nlogn) 1) For X on list L do 2) INSERT(X,heap); O(nlogn) 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])

דוגמה 3 4 7 9 8 11 3 4 7 9 8 11 11 4 7 9 8 3 Swap(11,3) 4 8 7 9 11 3 Pushdown(11) Swap(11,4) 11 8 7 9 4 3 7 8 11 9 4 3 Pushdown(11)

עד כאן: מעבר ממערך HEAP-י למערך ממוין 9 8 11 7 4 3 Swap(9,7) Pushdown(9) 8 9 11 7 4 3 11 9 8 7 4 3 לבסוף נקבל: 11 9 8 7 4 3 עוד n/2 החלפות ==> סדר עולה! עד כאן: מעבר ממערך HEAP-י למערך ממוין

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

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

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

BIN SORTING בקירוב: ((nlogn אם לא יודעים כלום על המספרים מיונים שראינו עד כה: (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

דוגמה 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-ים

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

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

פתרון: - הכן n סלים - מיין לפי הספרה הפחות משמעותית - מיין לפי הספרה היותר משמעותית Bin 1 2 3 4 5 6 7 8 9 איברים 1, 81 - 64, 4 25 36, 16 9, 49 Bin 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 שרשור

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

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

RADIX SORT - נתונים k מפתחות f1,…,fk - רוצים למיין בסדר לכסיקוגרפי כלומר: (a1,…,ak) < (b1,…,bk) אמ”ם: 1) a1 < b1 2) או a1 = b1, a2 < b2 a1 = b1,…., ak-1 = bk-1, ak = bk (k דומה ל BIN SORT מוכלל, רק צריך לכל סוג מפתחות את תחום הסלים שלו.

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

abc acb bac bca cab cba bac bca cba abc acb cab bca cba bac acb cab 1 bac bca cba abc acb cab 2 3 כן לא A[2]<A[1]? (b<a?) bca cba bac acb cab abc 4 5 6 7 A[3]<A[2]? (c<a?) cba bca cab acb 8 9 10 11 A[2]<A[1]?

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

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

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

סטטיסטיקת סדר ומציאת חציון 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

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

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

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

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

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

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