שיעור עשירי: מיונים – ב'

1. שיעור עשירי: מיונים – ב' מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

2. מקורות נוספים: מבוא לאלגוריתמים פרק 7 תודות לד"ר ראובן חוטובלי שחומרי ההוראה שלו סייעו בהכנת המצגת מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

3. תור עדיפויות • תור* עדיפויות(priority queue) הוא טיפוס אוסף* המטפל בנתונים בהתאם לעדיפויות שלהם: • לכל איבר מוגדרת עדיפות מסויימת • סדר הכנסת האיברים הינו שרירותי • הטיפול נעשה לפי סדר העדיפויות: האיבר הראשון לטיפול הינו בעל העדיפות הגבוהה ביותר • *תור כאן - לא במשמעות של טיפוס הנתונים המופשט "תור"! • * טיפוס נתונים מופשט מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

4. שימושים בתור עדיפויות • ניהול הדפסות מצטברות שאינן שוות קדימות • ניהול משאבי זמן CPU במערכות מרובות תהליכים מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

5. first עדיפות מקסימלית 100 20 20 5 ייצוג תור עדיפויות בעזרת רשימה • נחזיק רשימה מקושרת ממוינת בסדר לא עולה של עדיפויות מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

6. ייצוג תור עדיפויות בעזרת רשימה • האיבר בעל העדיפות הגבוהה ביותר נמצא תמיד בראש הרשימה • מציאת האיבר ה"עדיף" ביותר נעשית ב- O(1) • מחיקת האיבר העדיף היא ב-O(1) • הכנסת נתון חדש לוקחת O(n) (n = מס' האיברים באוסף) [צריך לחפש מקום להכנסה לפי סדר עדיפויות] מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

7. 5 עדיפות מקסימלית 8 2 1 6 3 9 ייצוג תור עדיפויות בעזרת עח"ב • נחזיק עץ חיפוש בינרי הממוין לפי עדיפויות: כך האיבר בעדיפות המירבית יהיה תמיד בצומת הימני ביותר: מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

8. ייצוג תור עדיפויות בעזרת עח"ב • כדי שמציאת האיבר העדיף תיעשה ב-O(1), נחזיק מצביע אליו (אותו יש לעדכן בעת הכנסות/מחיקות) • פעולות מחיקת האיבר העדיף והכנסת נתון חדש לוקחות O(logn)בממוצע(תלוי כזכור במבנה העץ) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

9. עדיפות מקסימלית ייצוג תור עדיפויות בעזרת ערימה • ערימה (heap) היא מבנה נתונים (טיפוס) המאפשר מציאת איבר מקסימלי בין הנמצאים בערימה ביעילות מקסימלית O(1): מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

10. ייצוג תור עדיפויות בעזרת ערימה מחיקת האיבר העדיף והכנסת נתון חדש ייקחו: O(log n)במקרה הגרוע מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

11. ממשק טיפוס הנתונים ערימה • Heap() – הפעולה בונה ערימה ריקה (init) • insert (x) – הפעולה מכניסה ערך x לערימה ב-O(log n) • extractMax() – הפעולה מוציאה את האיבר המקסימלי מהערימה ומחזירה אותו ב-O(log n) • retrieve() (או findMax()) - הפעולה מחזירה את הערך המקסימלי בערימה מבלי למוחקו ב-O(1) • buildHeap (values) – הפעולה בונה ערימה עם הערכים הנתונים ב- O(n) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

12. עקרונות מימוש הערימה • הערימה היא עץ בעל צורה מסוימת • מטרות הערימה: • יעילות (בדומה לעץ חיפוש בינרי) • פשטות המימוש (יותר פשוט מעץ חיפוש בינרי) • את היעילות נשיג ע"י סידור צומתי העץ בצורה מסוימת – נקרא לזה "סדר הערימה" • את הפשטות נשיג ע"י מימוש העץ כעץכמעט מלא בתוך מערך מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

13. עץ בינרי מלא וכמעט מלא עץ בינרי כמעט מלא הוא עץ בינריבו ברמה של העלים, חסרים (אולי) כמה עלים ימניים ביותר: מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

14. a b c a d e f g 2 3 b c h i j k l m n o 4 5 6 7 d e f g 8 9 10 11 12 13 14 15 h i j k l m n o מימוש עץ בינרי כמעט מלא במערך 1 • אפשרי כאשר ידוע חסם עליון n על מספר הצמתים בעץ מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

15. מבנה הנתונים - ערימה (בינרית) • מערך המייצג עץ בינרי כמעט מלא • לכל צומת בעץ – מתאים תא במערך • למערך יש שתי תכונות: 1. אורך המערך 2. מספר האיברים המשמעותי המאוחסן במערך (size < length) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

16. מבנה הנתונים - ערימה (בינרית) • קיים קשר ברור בין צומתי העץ והאינדקסים של המערך: שורש העץ יושב לעולם ב- arr[1](לא משתמשים בarr[0]) הורה של צומת i מאוחסן בתא i/2 במערך (ערך שלם תחתון) בן שמאלי של צומת i מאוחסן בתא 2i בן ימני של צומת i מאוחסן בתא 2i+1 מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

17. 16 1 14 10 2 3 8 7 9 7 3 6 4 5 2 8 4 1 9 10 ייצוג הערימה מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

18. תכונת הערימה (בינרית) סדר הערימה(קובע את היעילות) נקבע בעזרת: • תכונת הערימה: לכל צומת i, פרט לשורש, מתקיים: ערך כל צומת קטן-שווה מהערך השמור בהורה של הצומת במילים אחרות: ערך צומת הוא לכל היותר ערך ההורה שלו. שאלות הבהרה: • היכן נמצא הערך הגדול ביותר בערימה? • ערך שצומת מכיל, גדול או שווה לכל הערכים ....? מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

19. סיכום ביניים • האיבר המקסימלי של הערימה נמצא בשורש כלומר בתא מספר 1. • מהרקורסיביות של הגדרת הערימה נובע כי לכל צומת, תתי העץ של הצומת הם ערימות. • העלים של העץ הם איברי החלק השני (הימני) של המערך. מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

20. כמה עלים בערימה? • טענה 1: יהי n אורכו של מערך arr, כלומר: n = arr.length האיברים בתת מערך arr[(n/2+1) …n] המייצג ערימה בינרית, הם כולם עלים. מסקנה: מחצית מאיברי הערימה הם עלים. מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

21. גובה של ערימה • טענה 2: גובה של עץ ערימה בינרית בעל n צמתים, הוא מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

22. מימוש פעולות הממשק של ערימה הפעולה הבונה: הקצאת מערך בגודל n+1(n חסם עליון של מספר האיברים בערימה) • אתחול size לאפס יעילות הפעולה בייצוג הנתון: O(1) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

23. מימוש פעולות הממשק של ערימה הפעולה extractMax – מחזירה את האיבר הגדול: • החזרת arr[1] יעילות הפעולה בייצוג הנתון: O(1) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

24. שמירה על מבנה הערימה הדבר המשמעותי ביותר הוא השמירה על מבנה הערימה, כלומר על תכונת הערימה • הפעולה תקרא: heapIfY(…) הקלט: הפעולה תקבל מערך ואינדקס ההנחה:העצים הבינריים שהם הילד הימני והשמאלי של האינדקס i, הם ערימות אך ייתכן שarr[i]- עצמו מפר את הסדר ויש לשבצו למקומו. המהלך: הפעולה תחליק את האיבר למקומו בערימה, כך שהעץ ששורשו ב-arr[i] יהפוך לערימת מקסימום. הפלט: מערך המייצג ערימת מקסימום. מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

25. אלגוריתם לשמירה על מבנה הערימה heapIfY (arr, i) step1+2. l  Left(i) r  Right(i) Step3 if l  arr.heapSize and arr[l] > arr[i] then largest  l else largest  i step4 if r  arr.heapSize and arr[r] > arr[largest] then largest  r step5 if (largest != i) {exchange arr[i] arr[ largest]} heapIfY(arr, largest) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

26. אלגוריתם לשמירה על מבנה הערימה • אחרי צעד 4 מתקיים: • largest = l if arr[l] > max (arr[r],arr[i]) r if arr[r] > max (arr[l],arr[i]) • i if A[i] > max (arr[l],arr[r]) • בכל שלב נקבע האיבר הגדול ביותר מביןarr[right(i)],arr[left(i)],arr[i] והאינדקס שלו מוצב ב- largest.אם largest=i אז סיימנו! מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

27. 16 1 4 10 2 3 14 7 9 3 4 5 6 7 2 8 8 1 9 10 דוגמה לפעולה heapIfY 16 heapIfY(arr,2) 14 10 4 7 9 3 2 8 1 מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

28. שמירה על מבנה הערימה • אםarr[i] הוא הגדול ביותר אזי תת-העץ המושרש בצומת i הוא ערימה והשיגרה מסתיימת. • אחרת: אחד משני בניו מכיל את האיבר הגדול ביותר. לכן arr[largest] ו- arr[i] מוחלפים זה בזה. • לאחר ההחלפה הצומת i ובניו מקיימים את תכונת הערימה. • אולם הצומתlargest מכיל עתה את הערך המקורי arr[i] ויתכן שתת העץ המושרש ב-largest מפר את תכונת הערימה. • לכן יש לקרוא באופן רקורסיבי ל- heapIfY עם תת עץ זה. מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

29. המשך הדוגמה: heapIfY 16 14 10 8 7 9 3 2 1 4 מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

30. יעילות הפעולה heapIfY הפעולה מבצעת סדרת החלפות על מסלול כלשהו משורש העץ לעלה. • על כל החלפה מתבצע מספר קבוע של פעולות (שתי השוואות ו-swap). • לכן, מספר הפעולות במקרה הגרוע הוא כגובה העץ. • מכיוון שגובה העץ חסום על ידי log n, אזי סדר הגודל של זמן הריצה של הפעולה כולה הוא O(log n). מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

31. בניית ערימה – הפעולה buildHeap הקלט: מערך arr כאשר n = length[arr] • הפלט: ערימה מכיוון שהאיברים במערך arr[(n/2+1) …n] כולם עלים של העץ, הרי שבתחילת התהליך כל אחד מהם הוא ערימה בת איבר יחיד. אם כך נוכל להפוך את המערך הנתון לערימה תוך שימוש ב-heapIfY על התאים שבתחילת המערך (מהסוף להתחלה) באופן הזה: מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

32. בניית ערימה – הפעולה buildHeap buildHeap (arr) heapSize[arr]  length[arr] for i length[arr]/2 downto 1 do heapIfY (arr, i) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

33. הזמן הנדרש להרצת HeapIfY על צומת שגובהו h הוא O(h), • בגובה זה ישנם צמתים לכל היותר. מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

34. לכן זמן הריצה הכולל של buildHeap הוא: מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

35. מסקנה: הזמן הדרוש לבניית ערימה הוא לינארי במספר הצמתים בה: O(n) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

36. בניית ערימה – הפעולה buildHeap buildHeap (arr) heapSize[arr]  length[arr] for i length[arr]/2 downto 1 do heapIfY (arr, i) משך זמן הריצה הוא ... ניתן לבנות ערימה ממערך לא ממוין בזמן לינארי! מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

37. הוצאת מקסימום מערימה הפעולהextractMax extractMax (arr) max  arr[1]; arr[1]  arr[heapSize[arr]]; heapSize[arr] heapSize[arr]-1; heapIfY (arr,1) return max משך זמן הריצה הוא ... מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

38. הדגמה: הפעולה extractMax 91 • נבצע extractMax(H): • עוד פעם extractMax (H): 76 86 61 72 20 37 18 57 65 43 10 15 29 מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

39. הכנסת איבר לערימה הפעולהinsert • הכנס את xכעלה אחרון למערך(איך זה יראה בעץ בינרי?) • כל עוד x גדול מאביו, החלף ביניהם (הפעולה נקראת sift-up) משך זמן הריצה של הפעולה O(log n), כי גובה העץ הוא log n יותר מדויק להגיד, שזמן הריצה הוא מסדר גודל O(log n), כאשר n הוא מספר האיברים שבפועל נמצאים במבנה (size) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

40. הכנסת איבר לערימה הפעולהinsert insert (arr, key) heapSize[arr]  heapSize[arr]+1 i  heapSize[arr] while i>1 and arr[parent(i)] < key do{ arr[i]  arr[parent(i)] i  parent(i) } arr[i]  key שימו לב שאין החלפה בין הערכים במערך אלא רק הזזה של הקטן למקומו... מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

41. 15 7 8 10 14 16 2 1 1 9 3 7 8 10 14 16 2 4 4 9 3 1 4 15 8 10 14 16 2 1 3 4 3 9 14 8 10 15 16 2 7 7 9 הדגמה: הפעולהinsert הכנסת הערך 15 נעקוב בעזרת המערך המתאים: מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

42. הדגמה: הפעולהinsert 91 • נבצע insert(H, 43): • נבצע insert(H, 30): • נבצע insert(H, 95): 76 86 61 72 20 37 18 57 65 43 30 95 מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

43. ערימת מקסימום וערימת מינימום • מבדילים בין ערימת מקסימום וערימת מינימום • בערימת מינימום, כל הורה בעץ קטן משני ילדיו או שווה להם. • בערימת מקסימום, כל הורה גדול משני ילדיו או שווה להם. מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

44. מיון* ערימה heap sort רעיון האלגוריתם הכללי: בהינתן מערך arr בגודל n, ניתן למיינו באופן הזה: נבנה ערימה ממערך הקלט, n = arr.length בתום הבנייה האיבר הגדול נמצא בarr[1]-. ניתן להחליפו עם arr[n]. אם מסלקים את הערך הזה מהערימה על ידי הקטנת heapSize, ניתן בקלות להפוך את המערך המקוצר לערימה בעזרת זימון אחד של heapIfY(רק השורש יכול להיות לא במקום ויש לשמור את תכונת הערימה). תהליך זה יחזור על עצמו עבור ערימה בגודל n-1 והלאה עד ערימה בגודל 2: *בדברנו על מיון אנו מתכוונים למיון בסדר עולה! מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

45. מיון ערימה heap sort heapSort (arr) buildHeap(arr); for i=length[arr] downto 2 do { exchange (arr[1],arr[i]) heapSize[arr]=heapSize[arr]-1 heapIfY(arr,1) } מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

46. 3 2 1 7 4 3 8 9 2 1 7 4 3 9 1 9 7 3 4 2 2 8 8 2 2 1 7 3 4 1 8 8 1 3 7 9 8 7 1 4 2 9 8 7 1 1 3 2 4 1 4 2 1 2 3 3 9 1 1 2 3 4 2 3 7 8 9 4 7 8 9 4 7 8 9 4 7 8 9 1,2,3,4,7,8,9 3 2 3 4 7 8 9 4 7 8 9 מעקב אחר heap sort מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

47. זמן הריצה: heap sort זמן הריצה של מיון ערימה הוא O(n log n) במקרה הגרוע. נסביר: זמן הריצה של buildHeap הוא O(n) זמן הריצה של כל זימון בודד של heapIfY הוא O(log n) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

48. מיון ערימה • יהיה ביעילות O(n log n) (טוב כמו מיון מיזוג) • יתבצע במקום (כמו מיון הכנסה ובחירה) • מאחד את היתרונות במיונים השונים • היתרונות נצברים מאופן השימוש במבנה הנתונים מערך כערימה. • למרות האלגוריתם הטוב, מימוש טוב של מיון מהיר יהיה מהיר ממנו ביישומים מעשיים! • הערימה כמבנה נתונים משמשת ליישומים נוספים (תור קדימויות ראינו) מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008