1. 1 ייצוג באמצעות עצים שונים מתוחכם רק לקבוצות גדולות (תקורה בפעולות ובתכנות!!!) עצי חיפוש בינאריים BINARY SEARCH TREES תחום סדור (> < =) תחום איברים גדול (איברי הקבוצה לא יכולים להיות אינדקסים לתוך מערך) דוגמה: השמות בתוכנית פסקל עץ חיפוש בינארי יתמוך ב: INSERT DELETE MEMBER MIN הבדל מ - DEL+MIN :Heap נבצע ב- O(logn) בממוצע Data Structures, CS, TAU - 5.1 ייצוג קבוצות מתוחכם

2. 2 הגדרה: - הצמתים מסומנים בערכים - העץ בינארי לא בהכרח מאוזן לא בהכרח מלא - לכל צומת v שערכו x : תת העץ הימני > x תת העץ השמאלי < x דוגמה: abc abaabf abdacc acbabe abf abc aba acc acb abd abe - זהות בקבוצות - שונות בייצוג ביצוע MEMBER רוץ על פני העץ (ימינה ושמאלה ע”פ הגדלים) עד שתמצא Data Structures, CS, TAU - 5.2

3. 3 Type nodetype = redord element: elementtype; leftchild, rightchild: nodetype; end; function MEMBER (x: elementtype; A:SET): boolean {return TRUE if x A} begin if A=nil then return(false) else if x=A.element then return(true) else if x<A.element then return(MEMBER(x, A.leftchild)) else {x>A.element} return(MEMBER(x, A.rightchild)) end; {MEMBER} Data Structures, CS, TAU - 5.3 יישום במצביעים

4. 4 חפש כמו ב- MEMBER ועם המצביע שמצביע על NIL נצביע על צומת חדשה שמכילה את x יישום DELETE(x, A) - אם x עלה: תלוש את העלה - אם ל x בן יחיד: תלה את הבן במקום x - אם ל x שני בנים: קח את הקטן ביותר (שמאלי ביותר) בתת העץ הימני, השמיטו ושים במקום x x x Data Structures, CS, TAU - 5.4 יישום INSERT (x,A)

5. 5 יישום FINDMIN רוץ שמאלה ככל האפשר יישום FINDMAX רוץ ימינה ככל האפשר יישום DELETEMIN שלב את FINDMIN ואת DELETE (ניתן גם לישם DELMIN ישירות ותוך כדי שימוש בו ליישם את DELETE – ראה AHU [158-159] ) (לך שמאלה ככל האפשר והשמט, תוך כדי תליית הבן הימני) Data Structures, CS, TAU - 5.5

6. 6 1) O(n) : Worst Case 2) כמה זמן לוקח בממוצע להכניס n איברים אקראיים? עץ מושלם: עץ קווי: על איבר לוקח לכל היותר log n O(n) לצומת ממוצע: צריך להניח הנחות - רק INSERT - כל הסדרים שווי הסתברות (סדרים בין n אלמנטים) Data Structures, CS, TAU - 5.6 אנליזת זמן של עץ חיפוש בינארי Finished 8/12/03

7. 7 - רוצים לחשב אורך מסלול ממוצע: קח את האיבר הראשון (a) ההסתברות ש I איברים קטנים ממנו היא a iN-i-1 יהי P(i) אורך ממוצע של מסלול בעץ בגודל i (אורך מסלול כאן = מס’ צמתים במסלול) אזי, אם i איברים קטנים מ- a, האורך הממוצע הוא: שמאל ימין מרכז (j=n-i-1) Data Structures, CS, TAU - 5.7

8. 8 נוריד את ההתניה על i: הצב: נראה באינדוקציה: הוכחה: Data Structures, CS, TAU - 5.8

9. 9 Data Structures, CS, TAU - 5.9

10. 10 - גמישות בבינאריות גמישות בעומק - עץ חיפוש בינארי: ממוצע O(log n) גרוע ביותר (O(n - היינו רוצים לשמור את העץ מאוזן תמיד Data Structures, CS, TAU - 5.10 יישום קבוצות באמצעות עצים מאוזנים - קשיחות בבינאריות קשיחות בעומק

11. 11 הגדרה: 1) לכל צומת פנימי 2 או 3 ילדים 2) כל מסלול משורש לעלה - באותו אורך ייצוג קבוצה מסודרת: - האלמנטים נשמרים בעלים, מסודרים בסדר עולה משמאל לימין. - הילדים ממוספרים (3,2,1) משמאל לימין. - בכל צומת פנימי שומרים את המפתח הנמוך ביותר בתת העץ האמצעי ו(אם צריך) הנמוך ביותר בתת העץ הימני דוגמה: 613 17 - 11 9 5 - 5296 1317 חציצים (בין כל זוג איברים) Data Structures, CS, TAU - 5.11 שימוש בעצי 2-3 (B-trees)

12. 12 תכונות: INSERT,DELETE,FIND, FINDMIN.MEMBER, O(logN) Worst Case :MEMBERלך על פי הערכים (כמו עץ חיפוש בינארי) :INSERT v - צומת חדש p - צריך להיות אבא של v g - אבא של p (סבא של v) - הכנס v כבן נוסף של p - אם כעת ל p שלושה ילדים - גמרת. - אם ל p יש ארבעה ילדים: פצל p ל- p שמאל ו- ‘p מימין ושתול את ‘p כבן של g Data Structures, CS, TAU - 5.12

13. 13 לצורך שתילה של v ב p צריך לדעת: 1) מצביע ל- v 2) ערך הנמוך ביותר בתת העץ של v שים לב: פרט למקרה יחידי (שמאלי ביותר והכי למטה), כל השתילות הן של צומת שלא השמאלי ביותר!!! כלומר, תמיד מוסיפים בן שהוא אח ימני לבן הראשון l1l1 l2l2 t1t1 t2t2 t3t3 l1l1 l2l2 t1t1 t2t2 t3t3 t’ 1 - t1t1 l’ 1 - t2t2 t3t3 l2l2 l1l1 Data Structures, CS, TAU - 5.13

14. 14 715 18 - 12 9 6 - 6397 1518 הכנסת 8 9 - 15 - - 12 63879 18 17 - 8 - 15 Data Structures, CS, TAU - 5.14 דוגמה ל-INSERT

15. 15 אפשרות א: 1) מצא מקומו של x 2) שתול את x באביו במעבר מלמטה למעלה מצריך: 1) מעבר מעלה מטה - מעבר מטה מעלה 2) התייחסות להורים אפשרות ב: שתילה רקורסיבית של x בתת העץ של node פרמטרים:x ערך לשתילה. node תת העץ שבו תבוצע ההשתלה. ערכים מוחזרים: Pnew - מצביע לתת עץ חדש לימינו של node low - הערך הקטן ביותר בתת העץ של Pnew חשוב: לוודא שפרמטרים וערכים מוחזרים מדוייקים. Data Structures, CS, TAU - 5.15 ביצוע של INSERT(x)

16. 16 - שימוש ברקורסיה כמו קודם. - בדיקות לגבי השורש 1) בדיקה האם העץ ריק או בעל איבר בודד וטיפול מתאים. 2) במקרה של עץ רגיל, רקורסיה עשוייה לחזור עם צומת חדש שמועמד להיות אח לשורש הקודם. צריך ליצור שורש חדש !!! Data Structures, CS, TAU - 5.16 טיפול במקרי קצה

17. 17 v - צומת p - אב u - דוד - השמט v מ p 1) אם ל v שני אחים: השמט וסיים. 2) אם ל v אח בודד: א) אם ל u שלושה בנים: p יאמץ אחד מבני הדוד ב) אם ל u שני בנים: u יאמץ את האח של v ועכשיו p ערירי צריך רקורסיבית להשמיטו p v 1 v d p a u c b p b a u d c 2א2א p a v u c b c u b a p 2ב2ב Data Structures, CS, TAU - 5.17 DELETE

18. 18 פונקציה DELETE1 : לוקחת מצביע ל node ומשמיטה את x מתת העץ של node - היישום לא כולל עדכון ערכים נמוכים. - לשם עדכון: צריך להחזיר את הערך הנמוך ביותר בתת העץ! - עדכון כלפי מעלה חייב להמשך גם אם לא משמיטים הצומת הספציפי. 3 3 45 4 פונקציה DELETE: קוראת ל DELETE1 עם השורש ובודקת מקרי קצה: א) אם בעץ יש צומת אחד או אם ריק. ב) אם התוצאה היא צומת בודד. Data Structures, CS, TAU - 5.18 יישום ב-AHU

19. 19 - רעיון דומה לעץ 2-3. - מעלה (דרגה) יותר גבוהה (k) לצמתים פנימיים. - עקרון גמישות רוחבית: בין k ל 2(k+1)/ (t 2t-1) - שימוש בדיסקים - הפקטור שמכתיב את k הינו גודל הדף. - ניתן ליישם ווריאציה שבה הערכים רק בעלים, או ווריאציה שבה יש ערכים בצמתים פנימיים. - כנ”ל לגבי עצי חיפוש בינאריים. Data Structures, CS, TAU - 5.19 B-TREES

20. 20 - מטפל בדרגה כללית. - מטפל בוורסיה שבה המפתחות שוכנים בכל העץ (לא רק בעלים) - מס’ המפתחות נעים בין k-1 ל 2k-1 דוגמה: n ih,f, b a,m,l, kd פעולה בסיסית ב InsertSPLIT אם מס’ המפתחות = 2k-1 פצל לשני צמתים, כ”א עם k-1 והעבר ערך אחד לאבא (החציון). דוגמה :Insert(j) n f b a,m,l, kd h i, j Data Structures, CS, TAU - 5.20 יישום CLR

21. 21 - קבוצות של קבוצות. - מאחדים קבוצות זרות ורוצים לדעת היכן כל עצם. - פעולות MERGE ו FIND - דוגמה: יחס האקוויולנטיות/שקילות (EQUIVALENCE ) מקיים: רפלקסיבי: סימטרי: טרנזיטיבי: a a b b a a b, b c a c נתון: רצף של פעולות שקילות 1 2, 3 4, 5 6, 2 3 רוצים: לייצר קבוצות שקילות. משתמשים ב- : MERGE לאיחוד הקבוצות FIND : לחפש למי שקול Data Structures, CS, TAU - 5.21 קבוצות עם MERGE ו-FIND 15/12/03

22. 22 MERGE(A, B) - בצע אחוד והכנס תוצאה ל A או B FIND(x) - מצא באיזו קבוצה נמצא x INITIAL(A, x) - הכנס x ל A יישום פשוט: - מערך שבו כל איבר מכיל את שם הקבוצה לה האיבר שייך A={1, 3, 5}, B={2, 4}, C={6, 7, 8} A B A B A C C C 1 2 3 4 5 6 7 8 יעילות: O(1) : FIND, INIT O(N) : MERGE (צריך לעבור על כל אברי המערך) מדד יעילות: N פעולות MERGE ו- FIND Data Structures, CS, TAU - 5.22 פעולות

23. 23 - לקשר את האיברים של A לחוד ושל B לחוד (רשימה מקושרת) - לא צריך לרוץ על כל אברי התחום אלא רק על אברי הקבוצה. - עדיין n מיזוגים יכולים לעלות: O(n ) 2 כי: רצף של n-1 מיזוגים שבו ממזגים את הקבוצה שנוצרה לאיבר בודד: פתרון: - לשמור את גודל הקבוצות - למזג קבוצות קטנות לגדולות Data Structures, CS, TAU - 5.23 יישום מהיר יותר

24. 24 סיבוכיות: 1) מתחשבנים עם כל איבר בנפרד (לא עם הקבוצה) 2) כשאיבר עובר קבוצה גודל קבוצת האם לפחות מוכפל. 3) גודל קבוצה ראשונית - 1 גודל קבוצה שנייה 2 גודל קבוצה שלישית 4גודל קבוצה רביעית 8 i-1 גודל קבוצה i 2 אבל גודל הקבוצה האחרונה N 2 #steps גודל קבוצה אחרונה N כל איבר עובר לכל היותר פעמים סבוכיות כוללת Data Structures, CS, TAU - 5.24 סיבוכיות

25. 25 1) צריך לכל קבוצה: א) גודלה ב) האיבר הראשון בה 2) צריך לכל איבר: א) קבוצת השייכות ב) האיבר הבא בקבוצה ישום: (הנחה: כל האיברים הם השלמים) type nametype = 1,…,n elementype = 1, 300, n MFSET = record setheaders: array[1…n] of record count: 0,…,n; firstelement: 0,…,n; end; names: array[1…n] of record setname: nametype nextelement: 0,…,n לכל קבוצה גודלה והאיבר הראשון לכל איבר שם הקבוצה והבא. Data Structures, CS, TAU - 5.25 מבנה נתונים

26. 26 - בודקים מי הקבוצה הקטנה (נניח A) - רצים לאורך הקבוצה ומשנים שמה ל- B - באיבר האחרון עושים את השרשור A ל- B - ב Headers מעדכנים את האיבר הראשון ואת גודל הקבוצה. סבוכיות: - כל איבר שעובר לבעלים חדשים, גודל הבעלים גדל פי שניים (לפחות) - לכן כל איבר עובר לכל היותר log n פעמים. סבוכיות : O(n log n) Data Structures, CS, TAU - 5.26 ביצוע MERGE

27. 27 - נסיון למנוע ריצה על כל אברי A כשמעבירים ל B- - בעץ מייצגים איברים. - כל צומת מצביע לאביו. - בשורש יושב שם הקבוצה. A 1 7 3 5 B 8 6 C 17 ביצוע הפעולות: MERGE(A, B) - תלה את השורש של A על זה של B FIND(x) - רוץ כלפי מעלה. Data Structures, CS, TAU - 5.27 יישום באמצעות עץ

28. 28 O(1) = MERGE O(n) = FIND (יתכן) N שידוכים וחיפושים O(n) 2 (אם תולים גדול על קטן נוצרת רשימה) שיפור: תלה עץ קטן על גדול - בכל תליה עומק גדל ב- 1. - בכל תליה מס’ הצמתים בעץ לפחות מוכפל. - צומת משתתף בתליה עומק כל צומת סבוכיות:(find) Data Structures, CS, TAU - 5.28 סיבוכיות

29. 29 כשמבצעים FIND לקפל את המסלול אל השורש (כל צמתי המסלול יהפכו לבני השורש( ביצוע קל: בשני מעברים (ראשון לזיהוי השורש, שני לקיפול ותליה) 1 7 A 3 2 8 1 7 A 3 2 8 FIND (7) ניתוח סיבוכיות: פעולה בודדת - עדיין יתכן O(n) ממוצע - מסובך לניתוח. אם לא תולים קטן על גדול, יקח O(NlogN) לבצוע FINDS N) קשה לאנליזה ( Data Structures, CS, TAU - 5.29 קיפול מסלולים

30. 30 אם כן תולים קטן על גדול, סבוכיות ל N פעולות: : (N) קרובה לקבוע אינה קבוע אבל גדלה לאט מאוד עם N פונקצית אקרמן: A(X, Y) A(0, y) = 1 A(1, 0) = 2 A(x, 0) = x+2 for x 2 A(x, y) = A(A(x-1, y), y-1), x,y 1 A(x, 0) = x+2 A(x, 1) = A(A(x-1), 1), 0) = A(x-1, 1)+2 = 2x A(x, 2) = A(A(x-1), 2), 1) = 2A(x-1, 2) = 2 x A(x, 3) = A(A(x-1), 3), 2) = 2 = 2 A(x-1, 3) 2 2 2 x פעמים A(x, 4) =אין צורה מתמטית הגדרה Data Structures, CS, TAU - 5.30

31. 31 הפונקציה :A(x) וריאציה של אקרמן: A(x) = A(x, x) A(1) = 2 A(2) = 4 A(3) = 16 A(4) = 2 2 2... 65536 פעם : (N) הפונקציה הופכית של :A(x) ה x הקטן ביותר כך ש n A(x) פונקציה מונוטונית עולה (לא יורדת) פרקטית חסומה ע”י 4 Data Structures, CS, TAU - 5.31