הורד מצגת
המצגת נטענת. אנא המתן
1
מיונים (SORTS) שמושים ביישומים רבים
יש n רשומות, לכל רשומה מפתח: K1,…..,Kn רוצים לסדר את הרשומות כך שהמפתחות לא בסדר יורד (יתכנו כפולים) קריטריונים ליעילות: לא תמיד זהה מספר פעולות מספר השוואות בין מפתחות
2
שיטות פשוטות 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.
3
סיבוכיות ספירת פעולות כל האלגוריתמים: חסם עליון - חסם תחתון- 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
4
סיכום: 3) Selection Sort
- רוב העבודה בהשוואת מפתחות ולא בהחלפת רשומות. - מספר החלפות (O(N עצה שימושית: אם הרשומות כבדות: החזק פוינטרים לרשומות מיין פוינטרים לאחר מיון, הזז רשומות ב (O(N צעדים סיכום: - אלגוריתמים פשוטים: ((n2), O(n2 - אלגוריתמים יעילים: (O(nlogn - נקודת חיתוך להחלטה: תלויה בהרבה גורמים - מאות - אלפים
5
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 רקורסיבית דוגמא לפיבוט: האיבר הגדול ביותר בין השניים השונים זה מזה משמאל
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
ניתוח סיבוכיות ניתוח סיבוכיות:
א) נראה ש (Partition(i, j לוקחת (O(j - i + 1 - התחשבנות עם כל איבר - לכל איבר מתבצע: א) הגעה עם המצביע ב) אחד מהשניים: 1) ממשיכים עם מצביע- (O(1 2) 1. ממתינים 2. מחליפים (O(1 3. מקדמים מצביע - לא חוזרים לאיבר מסקנה: סיבוכיות (Partition(i, j היא (O(j - i + 1 ב) QuickSort- פרט לקריאה הרקורסיבית, הכל לינארי במספר האלמנטים זמן כולל: סכם על כל האלמנטים את מספר הפעמים שמשתתפים בקריאה = סכום העומקים של האלמנטים (כולם)
8
ג) Worst Case אם כל פעם נבחר לפיבוט את הגדול ביותר אז המערך בגודל n יתחלק למערך של 1 + מערך של n -1 n n - 1 n - 2 2 סכום העבודה בכל הרמות (עבודה לינארית באלמנטים) = סכום העומקים = n ( …… + n - 1) = O(n2) =
9
נגד: בניתוח מדוקדק- הפיבוט הקודם בד”כ בצד ימין של המערך הימני
ד) ממוצע הנחה 1: כל האלמנטים שונים זה מזה (אלמנטים זהים רק מקטינים סיבוכיות) הנחה 2: כל הסדרים של [A[i],…,A[j שווי הסתברות! נכון?!? בעד: אי אפשר להבחין בין האלמנטים כי כולם היו גדולים שווים לפיבוט הקודם נגד: בניתוח מדוקדק- הפיבוט הקודם בד”כ בצד ימין של המערך הימני בכל זאת: - לא כל כך משמעותי (איבר בודד) - אם כן משמעותי: ערבב האיברים בצורה אקראית נאמץ את ההנחה!
10
סימון: (T(n זמן מיון מערך בגודל n.
הסתברויות: החלף בין בני הזוג ראשון הוא i + 1st שני קטן מ i + 1
11
נניח: נוכיח (באינדוקציה): אם C=4C2
12
הערות ושיפורים QuickSort- המהיר ביותר בממוצע מכל אלגוריתמי ה nlogn
זרוז האלגוריתם: נוכל לדאוג שהפיבוט יהיה מרכזי יותר. דוגמה: האמצעי מבין שלושה אלמנטים דוגמה: קח k אלמנטים ובחר אמצעי TradeOff : k קטן חוסר איזון k גדול מציאת אמצעי יקרה החלטה על סיום האלגוריתם: - אנחנו סיימנו ב n = 2 - עבור n קטן לא אכפת לנו שהסיבוכיות תהיה (O(n2 - Knuth ממליץ על n = 9 שימוש בפוינטרים לרשומות: - חוסך העתקות - עולה במצביעים
13
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
14
עקרון ה-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])
15
דוגמה 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)
16
עד כאן: מעבר ממערך 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-י למערך ממוין
17
להשלמת התמונה של מיון מערך שרירותי
צריך: העבר מערך למערך HEAP-י. דרך: החל מהשורה הלפני האחרונה בצע (Pushdown(i כלומר: דאג שתת העץ מתחת ל-i יהיה לגיטימי אנליזה: 1) בנית HEAP n/2 איטרציות- כ”א לכל היותר logn O(nlogn) למעשה: שנותן (O(n 2) ביצוע ה sort: n פעולות- כל-אחת logn O(logn)
18
הערות: 1) O(nlogn) :HEAP ב worstcase 2) ממוצע: קצת יותר גרוע מ QUICKSORT 3) אם רוצים רק את k הקטנים ביותר ממוינים: O(n+klogn) כניסה מיין k קטנים
19
MERGESORT עובד על ידי מיזוג רשימות מזג רשימות באורך 1 רשימה באורך 2
2 4 4 8 n n/2 כל מיזוג לינארי O(nlogn) (Cormen 13-15)
20
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 כל איבר מופיע מספר פעמים: מיון המערך ע”י: 1. ספירת האיברים מכל סוג 2. כתיבתם במערך תוצאה פרטים: Cormen
21
דוגמה 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-ים
22
פתרון: 1) כל BIN רשימה מקושרת 2) HEADERS מצביעים על תחילת הרשומה H1 E1 H2 E2 הכנסה: (O(1 שרשור: (O(1 כעת ניתן לשרשר מספר שרירותי של רשימות לתוך n סלים
23
אנליזה: דוגמה: 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
24
פתרון: - הכן 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 שרשור
25
למה עובד? למה טוב BIN SORT? נניח: i = 10a + b, j = 10c + d
נניח: i < j ברור ש - אם a < c אזי שלב שני ישים בסלים המתאימים, והמיון תקין. - אם a = c אזי b < d ולכן: מיון ראשון ימיין בסדר לכן i יכנס לסל לפני j בשלב השני למה טוב BIN SORT? - תחומים שידועה עליהם אינפורמציה כמו 1,…,nk (קבוע k) - מחרוזת באורך k
26
האם תמיד טוב? לא אם k מאוד גדול!! דוגמה: n = 100, k = 100 nk :BIN SORT
(100 מחזורים של 100 פעולות) מיון אחר: nlogn ו nk > nlogn אבל… זהירות בהשוואות! במיון רגיל- השוואה = (O(k ולכן יש חשיבות למודל החישובי!!!
27
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 מוכלל, רק צריך לכל סוג מפתחות את תחום הסלים שלו.
28
חסם תחתון למיון בהשוואות
- מיונים בהשוואה: ((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]
29
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]?
30
חסם תחתון: עבור מיון שרירותי שתתנו לי, אראה לכם מקרה שייקח כמו החסם התחתון. - כל מיון שתבחרו יגדיר עץ. - אבחר את המסלול בעץ. - עץ הוא בינארי: אם בעץ k עלים, אזי קיים מסלול שאורכו לפחות logk!! (עץ בינארי מלא ומאוזן בוודאי logk, אם לא מלא פחות עלים!!) - העלים מייצגים סדרים בסיסיים ואת כולם! - מספר הסדרים הוא !n. לכן אורך המסלול המקסימלי (!log(n
31
חסם תחתון לזמן ממוצע - אפשר להראות שגם הוא ((nlogn
- צורת ההוכחה: להראות שעץ בינארי k עלים - עומק מסלול ממוצע logk. הוכחה בשלילה: יהי T הקטן ביותר כך שלא מתקיים. אז ל T בן אחד או שניים: א) אם בן בודד סתירה לקטן ביותר n 1n עומק ממוצע קטן מ logk k עלים 1n 2n n ב) אם שני בנים: מספר העלים בהם הוא k1 ו- k2 k1<k k-k1=k2
32
אזי ממוצע אורך מסלולים לעלים ב T הוא:
- מציאת חסם תחתון לביטוי, ע”י מציאת מינימום שלו (תחת אילוץ k1+k2=k) פתרון התרגיל נותן מינימום ב k1=k2
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
2) מציאת מינימום: כנ”ל (O(n 3) מציאת מינימום ומקסימום: צורה פשטנית השוואות תחכום דורש רק השוואות: - קח זוג נתונים מהקלט: a,b - השווה a ל- b - השווה הגדול ל max - השווה הקטן ל min רק 3 פעולות לשני איברים 4) מציאת שני בגודלו: פעולות 4) מציאת k בגודלו: פעולות שכלול: בצע על HEAP דורש:
35
הקשה ביותר בין סטאטיסטיקות הסדר
2) מציאת חציון: הקשה ביותר בין סטאטיסטיקות הסדר בשיעור זה: חציון וכל סטאטיסטיק (O(n א) מציאה אקראית בזמן ממוצע (O(n בצע partition אקראי חפש בצד הנכון 1) סיבוכיות O(n2) :worst case כי איטרציה 1: n איברים 2: n-1 איברים וכו’ 2) סיבוכיות ממוצעת: (גודל צד שמאל של החלוקה מתפלג אחיד בין 1 ל n)
36
נניח אינדוקטיבית: נוכיח: (כי אפשר לבחור c גדול מספיק)
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
גדולים x 3n/10 קטנים חציון החציונים אנליזה: סכום השברים קטן מ 1 (O(n
רקורסיה חציון החציונים סכום השברים קטן מ 1 (O(n
39
הוכחה: (ניתן לבחור c גדול מספיק כך ש (c(n/10-7 גדול מהפונקציה המתוארת ע”י (O(n
מצגות קשורות
