1. תרגול 9
Heaps
Lempel-Ziv

2. Heaps 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).
Maximum-Heap
For each node x, x ≥ left(x) and x ≥ right(x) The root in a Maximum-Heap is the maximal element in the heap
Minimum-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
Heap-Array
A heap can be represented using an array:
A[1] - the root of the heap (not A[0])
length[A] - number of elements in the array
heap-size[A] - number of elements in the heap represented by the array A
For each index i :
Parent(i) = 𝑖 2
Left(i) = 2i
Right(i) = 2i+1

3. Heaps Insert ~ O(log(n)) Max ~ O(1) Extract-Max ~ O(log(n))
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))

4. 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

5. 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

6. 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

7. 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

8. 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

9. שאלה 1
בערימה H שמיוצגת בעזרת מערך, הציעו אלגוריתם להוצאת הערך במיקום ה-i (הניחו כי i קטן מגודל הערימה).
מה זמן הריצה של האלגוריתם?

10. שאלה 1 הדגמה: בצעו Extract(H,2) 7 11 9 21 12 13 20 34 22 51 14 14 9 11 17 21 12 13 20 34 22 51 14 14
הדגמה:
בצעו Extract(H,2) 7 11 9 21 12 13 20 34 22 51 14 14

11. שאלה 1
בערימה H שמיוצגת בעזרת מערך, הציעו אלגוריתם להוצאת הערך במיקום ה-i (הניחו כי i קטן מגודל הערימה).
מה זמן הריצה של האלגוריתם?
Solution:
Extract(H, i)
key  H[i]
H[i] H[heap_size] /*Deleting the i'th element and replacing it with the last element*/
heap_size  heap_size − /*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
אם כך, מדוע ייתכן שנצטרך לבצע up-heapify?
כי יכול להיות שהאיבר יכנס לתת העץ השני ז"א שהאיבר האחרון נמצא נניח בתת העץ השמאלי של השורש ואנו ומוציאים איבר מתת העץ הימני של השורש, אז אולי נצטרך לדחוף אותו למעלה.
H[heap_size] בעומק גדול יותר מH[i] (או לפחות באותו עומק).
אם כך, מדוע ייתכן שנצטרך לבצע up-heapify?

12. שאלה 1 הדגמה: בצעו Extract(H,2) i Key = 11 key  H[i] 9 11 17 21 12 13 20 34 22 51 14 14
הדגמה:
בצעו Extract(H,2)
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

13. שאלה 2
בהינתן ערימת מקסימום H, מה סיבוכיות הזמן למציאת 3 האיברים הגדולים בH?
מה סיבוכיות הזמן למציאת C האיברים הגדולים בH? כאשר C הוא קבוע.

14. שאלה 2
פתרון:
לוקח 𝑂 1 למצוא את שלושת האיברים המקסימליים בH. האיברים הם:
השורש
הבן המקסימלי של השורש 𝑦
המקסימלי מבין הבן השני של השורש או אחד הבנים של 𝑦
מציאת האיבר ה C בגודלו בH יכול להיעשות בדרך דומה:
האיבר ה 𝑖 𝑡ℎ בגודלו הוא אחד מ𝑖 מלכל היותר 𝑖 איברים: הבנים של 𝑖−1 האיברים הגדולים ביותר שעוד לא נלקחו.
מציאת 𝐶 האיברים הגדולים ביותר לוקח 𝑂 𝐶 2 =𝑂 1
פתרון נוסף יכול להיות סידור כל האיברים של C השכבות העליוניות ואז מציאת C האיברים הגדולים ביותר.

15. שאלה 2
בהינתן ערימת מקסימום H, מה סיבוכיות הזמן למציאת 3 האיברים הגדולים בH?
מה סיבוכיות הזמן למציאת C האיברים הגדולים בH? כאשר C הוא קבוע.
מה עם C אינו קבוע?

16. שאלה 2 פתרון: אם C הוא אינה קבוע אז צריך להפעיל כלים יעילים יותר.
נשתמש בערימה נוספת אשר תכיל איברים מהערימה המקורית. כל איבר שיכנס לערימה החדשה מחזיק גם מצביעים לילדים המקוריים שלו.
נכניס לערימה החדשה את השורש של הערימה המקורית.
לאחר מכן נבצע C פעמים Extract-Max() על הערימה החדשה ובכל פעם שמוציאים איבר, נכניס לערימה החדשה את הבנים שלו מהערימה המקורית.
בכל שלב בערימה החדשה יש את האיברים הפוטנציאלים להיות האיבר הבא בגודלו.
בערימה החדשה יש פחות איברים (לכל היותר C) לכן נקבל כי הזמן הוא 𝑂 𝐶 log 𝐶 .
שימו לב כי לא משנים כללל את הערימה המקורית.

17. שאלה 2 הדגמה: מצאו את 5 המפתחות הקטנים ביותר בערימה בעזרת האלגוריתם
7 נכנס לערימה החדשה
7 יוצא, 11 ו13 נכנסים
11 יוצא, 12 ו21 נכנסים
12 יוצא, 14 ו51 נכנסים
13 יוצא, 17 ו20 נכנסים
14 יוצא 7 11 13 12 7 11 13 14 21 12 17 20 13 17 14 21 51 20 34 22 51 14 41 9

18. שאלה 3
מצא את זמני הריצה של מציאת האיבר ה- 𝑖 הקטן ביותר בקבוצה בגודל n בשימוש במבנים הבאים:
מיון
תור עדיפות (ערימה)
פתרון:
מיון:
מיין את כל האיברים בעזרת אלגוריתם מיון בזמן 𝑂 𝑛 log 𝑛 .
מצא את האיבר ה-𝑖 הקטן ביותר ב𝑂 𝑖 .
סה"כ 𝑂 𝑖+𝑛 log 𝑛 =𝑂 𝑛 log 𝑛 .
תור עדיפות:
בנה ערימת מינימום בזמן 𝑂 𝑛 .
בצע Extract-Min 𝑖 פעמים בזמן 𝑂 𝑖 log 𝑛 .
סה"כ זמן ריצה 𝑂 𝑛+𝑖 log 𝑛 (אם נשתמש בשאלה הקודמת נקבל 𝑂 𝑛+𝑖 log 𝑖 𝑛+𝑖 log 𝑖 ).

19. שאלה 4 נתונים שני ערימות מינימום 𝐻 1 , 𝐻 2 עם 𝑛 1 , 𝑛 2 איברים בהתאמה.
נתונים שני ערימות מינימום 𝐻 1 , 𝐻 2 עם 𝑛 1 , 𝑛 2 איברים בהתאמה.
כל האיברים ב 𝐻 1 קטנים האיברים ב 𝐻 2 .
איך ניתן לאחד את הערימות לערימה אחת 𝐻 עם 𝑛 1 + 𝑛 2 איברים, בזמן 𝑂 𝑛 2 ?
ניתן להניח כי שתי הערימות משתמשות במערך < מ- 𝑛 1 + 𝑛 2 .

20. שאלה 4 פתרון: אם 𝑛 1 ≥ 𝑛 2 : אם 𝑛 2 > 𝑛 1 :
אם 𝑛 1 ≥ 𝑛 2 :
צרף את איברי 𝐻 2 למערך של 𝐻 1 החל מהמקום ה 𝑛 1 +1 עד המקום ה 𝑛 1 + 𝑛 2 −1.
טענה: כל האיברים של 𝐻 1 הוכנסו כעלים לערימה.
הוכחה: עבור כל 𝑖∈ 𝑛 1 +1, 𝑛 1 + 𝑛 2 , האבא של 𝐴[𝑖] הוא 𝐴[ 𝑖 2 ] וכן מתקיים 𝑖 2 ≤ 𝑛 1 + 𝑛 2 2 ≤ 2 𝑛 1 2 ≤ 𝑛 1 . לכן האבא של כל איבר מ 𝐻 2 הוא איבר מהערימה 𝐻 1 .
מכיוון שכל האיברים מ 𝐻 1 הם קטנים מהאיברים של 𝐻 2 אז הערימה עדיין חוקית.
אם 𝑛 2 > 𝑛 1 :
נבנה ערימה חדשה עם כל האיברים של 𝐻 1 , 𝐻 2 בזמן 𝑛1 + 𝑛2 = 𝑂 2𝑛2 =𝑂 𝑛 2 .

21. שאלה 5
תארו אלגוריתם בזמן 𝑂 𝑛 log 𝑘 למיון k מערכים ממויינים 𝐴 1 ,…, 𝐴 𝑘 למערך ממויין אחד.
𝑛 הוא מספר האיברים הכללי וכמובן 𝑘≤𝑛.

22. שאלה 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]))

23. שאלה 6
Suppose that you had to implement a priority queue that only needed to store items whose priorities were integer values between 0 and k.
Describe how a priority queue could be implemented so that insert() has complexity O(1) and RemoveMin() has complexity O(k).
(Hint: This is very similar to a hash table.)

24. Question 6 Solution: Use an array A of size k+1 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. E.g.,
insert(v)
A[v.priority].add-to-tail(v)

25. Question 6
Solution:
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-head() /*Removes list's head and returns it dequeue*/
return v
return NULL

26. Lempel-Ziv
אלגוריתם לדחיסת נתונים. האלגוריתם מאפשר לשחזר את המידע הדחוס במלואו. משפחה של אלגוריתמים שמקורם בשני אלגוריתמים עיקריים שפותחו על ידי יעקב זיו ואברהם למפל בשנת
אלגוריתמים ששייכים למשפחה זו של אלגוריתמים, מיושמים באפליקציות כגון ZIP ו - GIF image compression.
בתרגול זה נראה את אחת מהגרסאות של האלגוריתם שמקורו באלגוריתם משנת LZ78.

27. Lempel-Ziv
הרעיון שעומד בבסיסו של הקידוד הוא: כל מילה בקידוד היא המילה הארוכה ביותר שנראתה עד כה בתוספת של אות אחת.
על מנת לעשות חיפוש יעיל של המילים שכבר קודדו נממש מבנה נתונים עצי שנקרא Trie או Prefix tree (ראו דוגמה בהמשך). העץ יהיה מעין מילון שנבנה בצורה דינמית ומייצג מילים שכבר קודדו בצורה יעילה.
מבנה הנתונים הוא היררכי. לכל צומת יש אבא ורשימה של ילדים. בנוסף כל צומת צריכה לשמור שני שדות: אינדקס – המסמן באיזה שלב הצומת הזאת נוצרה ותו שמחבר את הצומת הזאת לאבא שלו (מידע שמופיע על הצלעות בדוגמה המופיעה מטה).
צלעות שיוצאות מצומת מסוימת מייצגות אותיות שונות ששיכות לא"ב של הטקסט המקודד. השרשור של האותיות במסלול מהשורש לצומת מסוימת מייצגות מילים או רישאות של מילים שקודדו.

28. Lempel-Ziv

29. Lempel-Ziv בונים עץ התחלתי ששורשו מסומן ב- 0.
מאתחלים את רשימת הזוגות אשר מייצגת את הקידוד להיות רשימה ריקה ואת האינדקס הרץ מאתחלים לאפס.

30. Lempel-Ziv

31. Lempel-Ziv

32. Lempel-Ziv

33. Lempel-Ziv
הקידוד הסופי עבור המילה B הינו רשימת הזוגות שאגרנו במשתנה Pairs.

34. Lempel-Ziv
כעת נניח שהטקסט B הוא הטקסט הקודם בתוספת של האות a:

35. Lempel-Ziv
שחזור:
ניתן לשחזר את הטקסט המקודד מתוך רשימת הזוגות בלבד בדרך הבאה:
נחזיק מערך. ואינדקס שמתחיל מ1.
האיבר ה0 במערך יהיה ריק. עבור כל זוג (i,x), נשרשר למילה שבמקום הi המערך את האות x ונכתוב את התוצאה במקום האינדקס במערך.
כמו כן נוסיף את התוצאה לטקסט המשחוזר ונקדם את אינדקס ב1. (במידה ונתקלנו ב* רק נוסיף את המילה לטקסט המשוחזר)

36. Lempel-Ziv

37. Lempel-Ziv

38. Lempel-Ziv

39. Lempel-Ziv

40. Lempel-Ziv

41. Lempel-Ziv

42. Lempel-Ziv

43. שאלה 7
טקסט עם א"ב המכיל 27 תווים ('a','b','c',…,'z',' ') מקודד בעזרת קידוד למפל-זיו למערך בן 𝑛 זוגות.
מה אורך הטקסט הארוך ביותר שניתן היה לקודד כדי לקבל את 𝑛 הזוגות? תנו דוגמא למקרה שכזה.
מה אורך הטקסט הקצר ביותר שניתן היה לקודד כדי לקבל את 𝑛 הזוגות? תנו דוגמא למקרה שכזה.

44. שאלה 7
מה אורך הטקסט הארוך ביותר שניתן היה לקודד כדי לקבל את 𝑛 הזוגות? תנו דוגמא למקרה שכזה.
הטקסט הארוך ביותר מתקבל כאשר הזוג הראשון הוא מילה באורך 1, הזוג השני מייצג מילה באורך 2 וכך הלאה עד שהזוג ה𝑛-י מייצג מילה באורך 𝑛.
לכן אורך הטקסט יהיה …+𝑛= 𝑛 𝑛+1 2 =𝜃 𝑛 2 .
דוגמאות:
ניתן לקבל טקסט שכזה על ידי מילה שחוזרת על עצמה כמו “aaaaaaa…”.
דרך נוספת היא לייצר טקסט שחוזר על עצמו בתוספת תו אחד כמו : "נ נח נחמ נחמן ..."

45. שאלה 7
מה אורך הטקסט הקצר ביותר שניתן היה לקודד כדי לקבל את 𝑛 הזוגות? תנו דוגמא למקרה שכזה.
נחשוב על העץ שלנו. ככל שהענף ארוך יותר, כך המילה ארוכה יותר. וככל שהענף קצר כך המילה קצרה.
איך נקבל את הענפים הקצרים ביותר?
נכון! עץ מאוזן!

46. שאלה 7
מה אורך הטקסט הקצר ביותר שניתן היה לקודד כדי לקבל את 𝑛 הזוגות? תנו דוגמא למקרה שכזה.
בעץ יש 𝑛 קודקודים ולכל קודקוד 27, נבדוק כמה שכבות יש בעץ.
בשכבה הראשונה יש 27 קודקודים, בשכבה השניה וכך הלאה עד 27 𝐿 .
נקבל כי 𝑛= …+ 27 𝐿 ⇒𝐿≈ log 27 𝑛 .
לכן הטקס הקצר ביותר שניתן לקבל הוא באורך: 27+2⋅ …+𝐿⋅ 27 𝐿 =27+2⋅ …+ log 27 𝑛 ⋅ 27 log 27 𝑛 =𝜃(𝑛 log (𝑛) ).
דוגמא:
הדרך בא ניתן לקבל מקרה שכזה הוא לייצר את כל סדרות התווים האפשריות עד האורך L:
"abcd…z aaabac…azbabbbc…"