Practical Session - Heap

Transcription

1 Practical Session - Heap Heap Heap Maximum-Heap Minimum-Heap Heap-Array A binary heap can be considered as a complete binary tree, (the last level is full from the left to a certain point). For each node x, x left(x) and x right(x) The root in a Maximum-Heap is the maximal element in the heap For each node x, x left(x) and x right(x) The root in a Minimum-Heap is the minimal element in the heap A heap can be represented using an array: 1. A[1] - the root of the heap (not A[0]) 2. length[a] - number of elements in the array 3. heap-size[a] - number of elements in the heap represented by the array A 4. For each index i : Parent(i) = Left(i) = 2i i 2 Right(i) = 2i+1 Actions on Heaps Insert ~ O(log(n)) Max ~ O(1) Extract-Max ~ O(log(n)) Build-Heap ~ O(n) Down-Heapify(H, i) same as MaxHeapify seen in class but starting in the node in index i ~ O(log(n)) Up-Heapify(H, i) Fixing the heap going from node in index i to the root as in Insert() ~ O(log(n)) 1

2 Question 1 (Exam 2009) Given a maximum heap H, What is the time complexity of finding the 3 largest keys in H? What is the time complexity of finding the C largest keys in H? (C is a constant) What if C is not constant? Solution: It takes O(1) to find the 3 maximal keys in H. The 3 maximal keys in H are: The root The root's maximal son y The largest among y's maximal son and y's sibling Finding the C largest keys in H is done in a similar way: The i-th largest key is one of at most i keys, the sons of the i-1 largest keys that have not been taken yet, thus can be found in O(i) time. Finding the C largest keys takes O(C 2 ) = O(1) (Another solution would be ordering all the keys in the first C levels of the heap) If C is not constant we have to be more efficient, We will use a new heap, where we will store nodes of the original heap so that for each node entered we will have it sons as put in this new heap but we also preserve access to its sons as in the original heap. We first enter the root to the new heap. Then C times we do Extract-Max() on the new heap while at each time we Insert the original sons (the sons as in the original heap) to the new heap. The logic is as before only this time since the new heap has at most C elements we get O(C*log(C)). (note that we do not change the original heap at any point) Question 2 In a given heap H that is represented using an array; suggest an algorithm for extracting and returning the i'th indexed element. Solution: Delete(H, i) if (heap_size(h) < i) error( heap underflow ) key H[i] H[i] H[heap_size] /*Deleting the i'th element and replacing it with the last element*/ heap_size heap_size 1 /*Effectively shrinking the heap*/ Down-Heapify(H, i) /*Subtree rooted in H[i] is legal heap*/ Up-Heapify(H, i) /*Area above H[i] is legal heap*/ return key 2

3 Question 3 You are given two min-heaps H 1 and H 2 with n1 and n2 keys respectively. Each element of H1 is smaller than each element of H 2. How can you merge H1 and H2 into one heap H (with n 1 + n 2 keys) using only O(n 2 ) time? (Assume both heaps are represented in arrays of size > n 1 + n 2 ) Solution n 1 n 2 : Add the keys of H2 to the array of H1 from index n1+1 to index n 1 + n 2. The resulting array represents a correct heap due to the following reasoning. Number of leaves in H1 is l1, hence if l1 is even, the number of internal nodes is l1-1 and there are 2l1 "openings" for new leaves. l 1 + l 1 1 = n 1 2l 1 1 = n 1 2l 1 > n 1 n 2 If l1 is odd then there are l1 internal nodes and 2l n 2 openings All keys from H 2 are added as leaves due to the fact stated in formula 2l 1 > n 2. As all keys in H1 are smaller than any key in H2, the heap property still will hold in the resulting array. n 1 < n 2 : Build a new heap with all the elements in H1 and H2 in O(n 1 + n 2 ) = O(2n 2 ) = O(n 2 ). 3

4 Question 4 Give an O(nlogk) time algorithm to merge k sorted arrays A1.. Ak into one sorted array. n is the total number of elements (you may assume k n). Solution We will use a min-heap of k triples of the form (d, i, Ad[i]) for 1 d k, 1 i n. The heap will use an array B. 1. First we build the heap with the first elements lists A1...Ak in O(k) time. 2. In each step extract the minimal element of the heap and add it at the end of the output Array M. 3. If the array that the element mentioned in step two came from is not empty, than remove its minimum and add it to our heap. 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 < A d. length Heap-Insert(B,(d, i + 1, A d [i + 1])) Worst case time analysis: Build-Heap : O(k) Extract-Min : O(log k) Heap-Insert : O(log k) Total O(nlogk) 4

5 Question 5 Suppose that you had to implement a priority queue that only needed to store items whose priorities were integer values between 0 and k 1. Describe how a priority queue could be implemented so that insert( ) has complexity O(1) and RemoveMin( ) has complexity O(k). Be sure to give the pseudo-code for both operations. Hint: This is very similar to a hash table. Solution Use an array A of size k of linked lists. The linked list in the ith slot stores entries with priority i. To insert an item into the priority queue with priority i, append it to the linked list in the ith slot. insert(v) A[v. priority].add-to-tail(v) To remove an item from the queue, scan the array of lists, starting at 0 until a non-empty list is found. Remove the first element and return it the for-loop induces the O(k) worst case complexity. E.g., removemin( ) for i 0 to k-1 List L A[i] if( L.empty() = false ) v L.remove-from-head( ) /*Removes list's head and returns it = dequeue*/ return v return NULL 5

6 שאלה )30 6 נק' ממבחן 2008( חברת הבניה "מבנים בע"מ" רוצה לשמור את נתוני משכורות העובדים ולבצע מספר פעולות עליהם. החברה מעסיקה כבר n עובדים. הציעו מבנה נתונים בגודל,O(n) התומך בפעולות הבאות בזמנים הנתונים. זמן תיאור פעולה O(n) אתחול המבנה. employees היא רשימה לא ממוינת של n העובדים Init(employees, והמשכורות שלהם. median_key3 הוא השלישון של משכורות העובדים ידוע ונתון מראש ומשתנה ביחד עם העדכונים. median_key3) O(logn) למבנה הנתונים. k הוספת עובד בעל משכורת Insert(k) O(logn) הוצאת עובד בעל משכורת מינימאלית. אם יש יותר מאחד, אז יש להוציא אחד מהם. Remove_Min() O(logn) הוצאת עובד בעל משכורת מקסימאלית. אם יש יותר מאחד, אז יש להוציא אחד מהם. Remove_Max() O(1) הדפסת המשכורת הממוצעת של העובדים בחברה Average() O(1) הדפסת השלישון של משכורת העובדים בחברה )ראו הגדרה בהמשך( Median3() הגדרה: בגודלו. דוגמה: השלישון שווה לערך המופיע במקום ה- n 3 לאחרמיון האיברים, כלומר האיבר ה- n 3 עבור 7=n והערכים: 2,17,17,5,6,9,8 השלישון הוא 6 השלישון הוא 5 עבור 6=n והערכים: 2,9,9,8,6,5 השלישון הוא 5 עבור 6=n והערכים: 2,7,6,5,5,5 פתרון: הערות: 1. פתרון שבו 5 מתוך 6 הפעולות ירוצו בזמן הנדרש יקנה 50% מהנקודות 2. כתיבת "לא יודע/יודעת" במקום קשקושים, תקנה 20% מהנקודות הפתרון כולל 4 ערימות, מקושרות ביניהן. היא ערימת מינימום שתחזיק את כל האיברים. ערימה H1 היא ערימת מקסימום שתחזיק את כל האיברים. ערימה H2 n 3 ערימה H3 היא ערימת מקסימום שתחזיק את האיברים הקטנים ביותר. n n האיברים הגדולים ביותר. ערימה H4 היא ערימת מקסימום שתחזיק את 3 min max median H1 min-heap size: n H2 max-heap size: n H3 max-heap size: n 3 n H4 n 3 min-heap size: 6

7 Init כל איבר יופיע, אם כן, בשלוש ערימות:,H1 H2 ואחת מבין,H3. H4 כל המופעים יהיו מחוברים במצביעים הדדיים. כמו כן נשמור שני משתנים: - n מספר העובדים )האיברים(, ו sum- - סכום כל המשכורות. נבנה את 4 הערימות, עם הקשרים ביניהן, ונחשב סכום המשכורות. ב- H3 יהיו n 3 איברים: כל האיברים שקטנים מ,median_key3- ומספר איברים שערכם שווה ל - O(n) יהיו שאר האיברים. סה"כ זמן: H4 - ב.median_key. O(1) ב- sum / n נדפיס Average() -(1)O. נוכל להדפיסו ב על פי הבנייה, החציון ישב תמיד בשורש ערימה H3. Median3() ו- H2. ל- H1 k את האיבר נכניס ב- k. sum ב- 1 ואת n נגדיל את Insert(k) מקרה 1: Median3() : k נכניס את k ל- H4. ייתן ויש צורך להעביר איבר מ- H4 ל- H3 )במקרה ו- 1 = ). n mod 3 האיבר שיש להעביר, שנסמנו k, הוא האיבר המינימלי ב -H4 והוא נמצא בשורש של H4. נוציא את k מ- H4, ונכניס אותו ל- H3. אגב, k יכנס לשורש של H3 והוא יהיה השלישון החדש של מבנה הנתונים. מקרה 2: Median() : k < מקרה זה דומה למקרה 1. גם הפעם יש צורך בתיקון אם שלישון השתנה, כלומר n = 1 3. mod נעשה זאת ע"י הוצאת האיבר הגדול ביותר ב- H3 )אגב זהו השלישון, שנמצא בשורש(, והכנסתו ל -.H4 Remove_Min() הוצאת האיבר המינימלי. נמצא אותו ב -(1)O בשורש של H2, ובעזרת המצביעים נוכל להוציא אותו מן הערימות האחרות )בדומה ל - extract_min extract_maxשל / ערימה( ב-( O(logn. במידת הצורך יש להעביר איבר אחד בין הערימות H3 ו- H4 בדומה ל- Insert. Remove_Max() זהה ל,Remove_Min()- רק שנוציא את האיבר מהשורש של H1. במידת הצורך יש להעביר איבר אחד בין הערימות H3 ו- H4 בדומה ל- Insert. 7