1. יסודות מבני נתונים
תרגול 9: ערימה - Heap

2. שאלה: כמה זמן לוקח לחפש איבר בערימה?
maximum
שאלה: כמה זמן לוקח לחפש איבר בערימה?
תשובה: O(n), למרות שבערימה קיים סדר מסויים.

3. Heaps דוגמה: הוסיפו את 9 מוסיפים את הערך 9 כעלה
דוגמה:
הוסיפו את 9
מוסיפים את הערך 9 כעלה
מבצעים Up-Heapify לתיקון הערימה 7 11 13 21 12 17 20 34 22 51 14 41 9
Heap_size 7 11 13 21 12 17 20
קטן מאביו – מבצעים החלפה 34 22 51 14 41 9

4. Heaps דוגמה: הוסיפו את 9 מוסיפים את הערך 9 כעלה
דוגמה:
הוסיפו את 9
מוסיפים את הערך 9 כעלה
מבצעים Up-Heapify לתיקון הערימה 7 11 13 21 12 9 20 34 22 51 14 41 17
Heap_size 7
גדול מאביו – מסיימים 11 13
קטן מאביו – מבצעים החלפה 21 12 9 20 34 22 51 14 41 17

5. Heaps דוגמה: כעת בצעו Extract-min Key = 7
דוגמה:
כעת בצעו Extract-min
מוציאים את השורש (ושומרים את ערכו)
מעבירים לשורש את העלה האחרון
מבצעים Down-Heapify מהשורש לתיקון הערימה 7 11 9 21 12 13 20 34 22 51 14 41 17 17
Heap_size
Key = 7 7 11 9 21 12 13 20 34 22 51 14 41 17

6. Heaps דוגמה: כעת בצעו Extract-min Key = 7
דוגמה:
כעת בצעו Extract-min
מוציאים את השורש (ושומרים את ערכו)
מעבירים לשורש את העלה האחרון
מבצעים Down-Heapify מהשורש לתיקון הערימה 17 11 9 21 12 13 20 34 22 51 14 41 17
Heap_size
גדול מבנו הקטן – מבצעים החלפה
Key = 7 17 11 9 21 12 13 20 34 22 51 14 41

7. Heaps דוגמה: כעת בצעו Extract-min Key = 7
דוגמה:
כעת בצעו Extract-min
מוציאים את השורש (ושומרים את ערכו)
מעבירים לשורש את העלה האחרון
מבצעים Down-Heapify מהשורש לתיקון הערימה
מחזירים את הערך שנשמר 9 11 17 21 12 13 20 34 22 51 14 41 17
Heap_size
Key = 7 9 11
גדול מבנו הקטן – מבצעים החלפה 17
קטן מבנו הקטן – מסיימים 21 12 13 20 34 22 51 14 41

8. Heaps הדגמה: מחקו את האיבר השני i Key = 11 key  H[i] 7 11 9 21 12 13 20 34 22 51 14 14
הדגמה:
מחקו את האיבר השני
key  H[i]
H[i] H[heap_size]
heap_size --
Down-Heapify(H, i)
Up-Heapify(H, i)
return key
Heap_size
Key = 11 7
גדול מאביו – מסיימים
גדול מבנו הקטן – מבצעים החלפה 11 9
קטן מבנו הקטן – מסיימים 21 12 13 20 34 22 51 14 14
אם כך, מדוע ייתכן שנצטרך לבצע up-heapify?

9. Heaps הדגמה: מחקו את האיבר השישי i Key = 17 key  H[i] 7 11 15 21 12 17 20 34 22 51 14 14
הדגמה:
מחקו את האיבר השישי
key  H[i]
H[i]H[heap_size]
heap_size --
Down-Heapify(H, i)
Up-Heapify(H, i)
return key
Heap_size
Key = 17 7 11 15
גדול מבנו הקטן – מסיימים 21 12 17 20
קטן מאביו – מחליפים 34 22 51 14

10. Heaps הדגמה: מחקו את האיבר השישי i Key = 17 key  H[i] 7 11 15 15 21 12 14 14 20 34 22 51 14
הדגמה:
מחקו את האיבר השישי
key  H[i]
H[i]H[heap_size]
heap_size --
Down-Heapify(H, i)
Up-Heapify(H, i)
return key
Heap_size
Key = 17 7
גדול מאביו – מסיימים 11 15 21 12 14 20 34 22 51

11. Heaps 7 11 13 21 12 17 20 34 22 51 14 41
Heap size 7
שאלה: האם במחיקת שורש האיבר שהועתק לשורש תמיד ידרוש תיקון ? 11 13
תשובה: לא. לדוגמא, עץ עם שני צמתים, או עץ עם שלושה צמתים כך שהבן השמאלי של השורש יותר קטן מהבן הימני.
שאלה: יש עוד דוגמאות כאילו? 21 12 17 20 34 22 51 14 41

12. Heaps 7 11 13 21 12 17 20 34 22 51 14 41
Heap size 7
שאלה: האם במחיקת שורש האיבר שהועתק לשורש תמיד ידרוש תיקון ? 11 13
תשובה: לא. כדי שלא ידרש תיקון לאחר מחיקת השורש, העלה הימני ביותר חייב להיות גם האיבר השני בגודלו, ולכן צריך להמצא ברמה השנייה של העץ. לכן הדוגמאות לכך הם עצים עם לכל היותר שתי רמות. 21 12 17 20 34 22 51 14 41

13. Question 1
A max-heap is given as a heap-array A of size 15. The heap contains all keys in the range 1..15, each key exactly ones.
Where can be located the key 15? Specify possible indexes.
Answer: A[1]. in a max-heap the maximum is always at the root.
Where can be located the key 1?
Answer: anywhere on the last level, i.e., in A[8]…A[15].
Which keys can be located in A[2]?
Answer: We know that A is a complete tree, so a sub tree rooted by A[2] is also a complete tree with 7 nodes. Thus we need 6 elements smaller than A[2] to fill the sub tree of A[2], thus A[2] has to be at least 7.
Where can be located the key 13?
Answer: in A[2]…A[7]. There are exactly two elements larger than 13 (14, 15), so it can’t reside lower than level 2. On level two it can reside anywhere.

14. Question 2
Suggest a data structure for storing integers that supports the following operations.
Init(S)
Initialize data structure with n elements of S set
O(n) expected time
Max()
Return maximum
O(1) expected time
Insert(x)
Insert x
O(log n) expected time
Delete(x)
Delete x
S = {9, 7, 5, 4, 2, 1}
דוגמא:
איך נמחוק בזמן O(logn) ?
max heap 1 2 4 5 7 9
נשמתש בטבלת גיבוב בנוסף, עם מצביעים לערימה
Delete (7)
hash (7) = 7
 get pointer to 7 in the heap
 delete 7

15. Question 3
Given a max-heap H, what is the time complexity of finding the 3 largest keys in H?
פתרון:
שלושה אלמנטים הגדולים ביותר בערימה הם:
השורש
הבן הגדול של השורש, נסמן אותו ב Y
הגדול לבין הבן השני של השורש, ושני בניו של Y
בסה"כ ביצענו השוואה אחת למצוא את האלמנט השני בגודלו, ושתי השוואות למצוא את האלמנט השלישי בגודלו, כלומר ביחד 3 השוואות.

16. עבודה עצמית: לשדרג את האלגוריתם הנ"ל כך שיעבוד בזמן O(k logk)
Question 3
Given a max-heap H, what is the time complexity of finding the K largest keys in H?
פתרון:
K אלמנטים הגדולים ביותר בערימה הם:
הראשון בגודלו - השורש (מועמד יחיד)
השני בגודלו - הבן הגדול של השורש, נסמן אותו ב Y (שני מועמדים, השוואה אחת)
שלישי בגודלו - הגדול לבין הבן השני של השורש, ושני בניו של Y (שלושה מועמדים, שתי השוואות) …
ה Kי בגודלו – לפי האבחנה הנ"ל, יהיו K מועמדים מהם יבחר K-1) השוואות)
1+2+3+…+K-1 ≈ K(K+1)/2 = O(K2)
בסה"כ כמות ההשוואות שנבצע היא:
עבודה עצמית: לשדרג את האלגוריתם הנ"ל כך שיעבוד בזמן O(k logk)
פתרון: נשתמש בערימת עזר אליה נכניס בהתחלה שורש של הערימה הקיימת. כל פעם נוציא מהערימה הזו מקסימום, ובמקומו נכניס את הבנים שלו מהערימה המקורית. כאשר איבר מוכנס לערימת עזר, הוא שומר מצביע על עצמו בערימה המקורית.
זמן ריצה: בערימת עזר לכל היותר K איברים, בשלב שבו בוחרים את האיבר ה K י בגודלו. אז כל פעולת הכנסה והוצאת מקסימום לוקחת O(log k) . לכן, עבור K פעולות כאילו נבזבז O(k logk) זמן.

17. Question 4
נתונות שני ערימות מינימום 𝐻 1 , 𝐻 2 עם 𝑛 1 , 𝑛 2 איברים בהתאמה.
כל האיברים ב 𝐻 1 קטנים האיברים ב 𝐻 2 .
איך ניתן לאחד את הערימות לערימה אחת בזמן 𝑂 𝑛 2 ?
(ניתן להניח כי שתי הערימות משתמשות במערך < מ- 𝑛 1 + 𝑛 2 .)
פתרון:
אם 𝑛 1 ≥ 𝑛 2 :
נצרף את איברי 𝐻 2 למערך של 𝐻 1 החל מאינדקס 𝑛 1 +1.
מכיוון שכל האיברים של 𝐻 1 קטנים מהאיברים של 𝐻 2 נקבל ערימה מאוחדת חוקית.
אם 𝑛 2 > 𝑛 1 :
נבנה ערימה חדשה עם כל האיברים של 𝐻 1 , 𝐻 2 זמן ריצה: 𝑂 𝑛1+𝑛2 = 𝑂 2𝑛2 =𝑂 𝑛 2

18. Question 5
נתונים k מערכים ממויינים 𝐴 1 ,…, 𝐴 𝑘 עם מספר כולל של n ערכים כאשר 𝑘≤𝑛. תארו אלגוריתם בזמן 𝑶 𝒏 𝒍𝒐𝒈 𝒌 למיזוג של המערכים הנתונים למערך ממויין אחד.
𝐴 1 94
... 73 56 49 48 13 5 2 1
𝐴 2 75
... 62 37 32 25 3
𝐴 3 33
... 8 2 1
...
𝐴 𝑘 99
... 48 26 13 12 6 4
merge … 3 2 1

19. Question 5
פתרון: רעיון – נבנה ערימה שתשמור בכל שלב את האיברים החשודים להיות האיבר הקטן הבא. כלומר, נרצה לשמור את האיבר הראשון בכל אחד מהמערכים 𝐴 1 ,…, 𝐴 𝑘 . נשתמש בערימת מינימום אשר כל איבר בה הוא שלשה מהצורה (𝑑, 𝑖, 𝐴𝑑[𝑖]) כאשר 1 ≤ 𝑑 ≤ 𝑘, 1≤ 𝑖 ≤ 𝑛 . הערימה תיוצג ע"י המערך B. ראשית נבנה ערימה עם האיברים הראשונים במערכים 𝐴 1 ,…, 𝐴 𝑘 בזמן 𝑂 𝑘 . בכל צעד נוציא את האיבר המינימלי בערימה ונכניס אותו למערך הפלט M. נוציא את האיבר שהוצאנו מהמערך המקורי שלו ונביא משם את האיבר המינימלי הבא.
Worst case time analysis:
Build-Heap : O(k) – done 1 time
Extract-Min : O(log k) – done n times
Heap-Insert : O(log k) – done n times
Total: O(nlogk)
for d1 to k
B[d]  (d, 1, Ad[1])
Build-Heap(B) /*By the order of Ad [1] */
for j=1 to n
(d, i, x)  Extract-Min(B)
M[j]x
if i < Ad.length then Heap-Insert(B,(d, i+1, Ad[i+1]))

20. Question 6
נתונה קבוצה S המכילה n מספרים שלמים חיוביים. הציעו מבנה נתונים שמאחסן n מספרים שלמים חיוביים, ותומך בפעולות הבאות.
פתרון:
Init
Insert(x)
FindMin()
FindMax()
DelMin()
DelMax()
ערימת מינימום Hmin
משתנה נוסף max למקסימום שנעדכן אותו ב Insert √
למצוא מקסימום בערימת מינימום – O(n). אפשר להחזיק בנוסף לערך של מקסימום גם מצביע למקסימום בערימה. אבל צריך לאחר המחיקה של מקסימום גם לעדכן את המקסימום החדש – O(n) כדי למצוא אותו.
Hmin 4
דוגמא: 5 8
{7,5,9,4,8,11} 4 11 9
max = 11

21. Question 6
נתונה קבוצה S המכילה n מספרים שלמים חיוביים. הציעו מבנה נתונים שמאחסן n מספרים שלמים חיוביים, ותומך בפעולות הבאות.
פתרון:
Init
Insert(x)
FindMin()
FindMax()
DelMin()
DelMax()
ערימת מינימום Hmin
משתנה נוסף max למקסימום שנעדכן אותו ב Insert √
למצוא מקסימום בערימת מינימום – O(n). אפשר להחזיק בנוסף לערך של מקסימום גם מצביע למקסימום בערימה. אבל צריך לאחר המחיקה של מקסימום גם לעדכן את המקסימום החדש – O(n) כדי למצוא אותו.
Hmin 4
דוגמא:
{7,5,9,4,8,11} 5 8 4 11 9
max = 11

22. Question 6
נתונה קבוצה S המכילה n מספרים שלמים חיוביים. הציעו מבנה נתונים שמאחסן n מספרים שלמים חיוביים, ותומך בפעולות הבאות.
Init
Insert(x)
FindMin()
FindMax()
DelMin()
DelMax()
פתרון:
ערימת מינימום Hmin
נבנה שתי ערימות – אחת מינימום Hminוהשנייה מקסימום Hmax
ערימת מקסימום Hmax
מחיקה מערימת מינימום – O(logn)
מחיקה מערימת מקסימום ? צריך קודם לצמוא את האיבר המינימלי בה וזה לוקח O(n) זמן. √
מצביעים הדדיים בין Hmin לבין Hmax
Hmin
Hmax 4 11
דוגמא:
{7,5,9,4,8,11} 5 8 8 9 4 11 4 9 5 7
דוגמא למצביע הדדי

23. Question 6
Store the elements in two heaps, Min-Heap Hmin and Max-Heap Hmax with mutual pointers, each element has a pointer to the element with the same value in the other heap.
Init
Build Hmin in O(n) and Hmax in O(n)
Insert(x)
Insert x to Hmin in O(log n)
Insert x to Hmax in O(log n)
Update the pointers in O(1)
FindMin()
Return the root of Hmin in O(1)
FindMax
Return the root of Hmax in O(1)
DelMin
Delete the minimum from Hmin in O(log n)
Delete the same element from Hmax by following the mutual pointer in O(log n)
DelMax
Delete the maximum from Hmax in O(log n)
Delete the same element from Hmin by following the mutual pointer in O(log n)