הורד מצגת
המצגת נטענת. אנא המתן
1
ייצוג קבוצות מתוחכם עצי חיפוש בינאריים BINARY SEARCH TREES
ייצוג באמצעות עצים שונים מתוחכם רק לקבוצות גדולות (תקורה בפעולות ובתכנות!!!) עצי חיפוש בינאריים BINARY SEARCH TREES תחום סדור (> < =) תחום איברים גדול (איברי הקבוצה לא יכולים להיות אינדקסים לתוך מערך) דוגמה: השמות בתוכנית פסקל הבדל מ - DEL+MIN :Heap INSERT עץ חיפוש בינארי יתמוך ב: DELETE MEMBER MIN נבצע ב- O(logn) בממוצע Data Structures, CS, TAU - 5.1
2
הגדרה: דוגמה: ביצוע MEMBER - הצמתים מסומנים בערכים
- העץ בינארי לא בהכרח מאוזן לא בהכרח מלא - לכל צומת v שערכו x : תת העץ הימני > x תת העץ השמאלי < x דוגמה: abc aba abf abd acc acb abe - זהות בקבוצות - שונות בייצוג ביצוע MEMBER רוץ על פני העץ (ימינה ושמאלה ע”פ הגדלים) עד שתמצא Data Structures, CS, TAU - 5.2
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
יישום INSERT (x,A) יישום DELETE(x, A)
חפש כמו ב- MEMBER ועם המצביע שמצביע על NIL נצביע על צומת חדשה שמכילה את x יישום DELETE(x, A) x - אם x עלה: תלוש את העלה - אם ל x בן יחיד: תלה את הבן במקום x x - אם ל x שני בנים: קח את הקטן ביותר (שמאלי ביותר) בתת העץ הימני, השמיטו ושים במקום x Data Structures, CS, TAU - 5.4
5
יישום FINDMIN יישום FINDMAX יישום DELETEMIN רוץ שמאלה ככל האפשר
רוץ ימינה ככל האפשר יישום DELETEMIN שלב את FINDMIN ואת DELETE (ניתן גם לישם DELMIN ישירות ותוך כדי שימוש בו ליישם את DELETE – ראה AHU [ ] ) (לך שמאלה ככל האפשר והשמט, תוך כדי תליית הבן הימני) Data Structures, CS, TAU - 5.5
6
אנליזת זמן של עץ חיפוש בינארי
1) O(n) : Worst Case 2) כמה זמן לוקח בממוצע להכניס n איברים אקראיים? על איבר לוקח לכל היותר log n עץ מושלם: עץ קווי: O(n) לצומת ממוצע: צריך להניח הנחות - רק INSERT - כל הסדרים שווי הסתברות (סדרים בין n אלמנטים) Data Structures, CS, TAU - 5.6
7
- רוצים לחשב אורך מסלול ממוצע:
- רוצים לחשב אורך מסלול ממוצע: קח את האיבר הראשון (a) ההסתברות ש I איברים קטנים ממנו היא a i N-i-1 יהי P(i) אורך ממוצע של מסלול בעץ בגודל i (אורך מסלול כאן = מס’ צמתים במסלול) אזי, אם i איברים קטנים מ- a, האורך הממוצע הוא: שמאל ימין מרכז (j=n-i-1) Data Structures, CS, TAU - 5.7
8
נוריד את ההתניה על i: הצב: נראה באינדוקציה: הוכחה:
Data Structures, CS, TAU - 5.8
9
Data Structures, CS, TAU - 5.9
10
יישום קבוצות באמצעות עצים מאוזנים
ממוצע O(log n) - עץ חיפוש בינארי: גרוע ביותר (O(n - היינו רוצים לשמור את העץ מאוזן תמיד - קשיחות בבינאריות קשיחות בעומק - גמישות בבינאריות גמישות בעומק Data Structures, CS, TAU
11
שימוש בעצי 2-3 (B-trees) ייצוג קבוצה מסודרת: דוגמה:
1) לכל צומת פנימי 2 או 3 ילדים הגדרה: 2) כל מסלול משורש לעלה - באותו אורך ייצוג קבוצה מסודרת: - האלמנטים נשמרים בעלים, מסודרים בסדר עולה מימין לשמאל. - הילדים ממוספרים (3 ,2 ,1) משמאל לימין. - בכל צומת פנימי שומרים את המפתח הנמוך ביותר בתת העץ האמצעי ו(אם צריך) הנמוך ביותר בתת העץ הימני דוגמה: 6 13 17 - 11 9 5 2 חציצים (בין כל זוג איברים) Data Structures, CS, TAU
12
לך על פי הערכים (כמו עץ חיפוש בינארי) :MEMBER
תכונות: INSERT, DELETE, FIND, MEMBER, FINDMIN. 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
13
l1 l2 t1 t2 t3 t’1 - t1 t’1 l’1 t2 t3 l2 l1 שים לב:
לצורך שתילה של v ב p צריך לדעת: פרט למקרה יחידי (שמאלי ביותר והכי למטה), כל השתילות הן של צומת שלא השמאלי ביותר!!! 1) מצביע ל- v 2) ערך הנמוך ביותר בתת העץ של v כלומר, תמיד מוסיפים בן שהוא אח ימני לבן הראשון l1 l2 t1 t2 t3 l1 l2 t1 t2 t3 t’1 - t1 t’1 l’1 t2 t3 l2 l1 Data Structures, CS, TAU
14
דוגמה ל-INSERT הכנסת 8 7 15 18 - 12 9 6 3 9 - 15 12 6 3 8 7 18 17
Data Structures, CS, TAU
15
ביצוע של INSERT(x) 1) מצא מקומו של x אפשרות א:
1) מעבר מעלה מטה - מעבר מטה מעלה מצריך: 2) התייחסות להורים שתילה רקורסיבית של x בתת העץ של node אפשרות ב: x ערך לשתילה. פרמטרים: node תת העץ שבו תבוצע ההשתלה. ערכים מוחזרים: Pnew - מצביע לתת עץ חדש לימינו של node low - הערך הקטן ביותר בתת העץ של Pnew חשוב: לוודא שפרמטרים וערכים מוחזרים מדוייקים. Data Structures, CS, TAU
16
טיפול במקרי קצה - שימוש ברקורסיה כמו קודם. - בדיקות לגבי השורש
1) בדיקה האם העץ ריק או בעל איבר בודד וטיפול מתאים. 2) במקרה של עץ רגיל, רקורסיה עשוייה לחזור עם צומת חדש שמועמד להיות אח לשורש הקודם. צריך ליצור שורש חדש !!! Data Structures, CS, TAU
17
DELETE v - צומת p - אב u - דוד - השמט v מ p
Data Structures, CS, TAU 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 2א p a v u c b 2ב
18
יישום ב-AHU פונקציה DELETE1 : פונקציה DELETE:
לוקחת מצביע ל node ומשמיטה את x מתת העץ של node - היישום לא כולל עדכון ערכים נמוכים. - לשם עדכון: צריך להחזיר את הערך הנמוך ביותר בתת העץ! - עדכון כלפי מעלה חייב להמשך גם אם לא משמיטים הצומת הספציפי. 3 4 5 פונקציה DELETE: קוראת ל DELETE1 עם השורש ובודקת מקרי קצה: א) אם בעץ יש צומת אחד או אם ריק. ב) אם התוצאה היא צומת בודד. Data Structures, CS, TAU
19
B-TREES - רעיון דומה לעץ 2-3.
- רעיון דומה לעץ 2-3. - מעלה (דרגה) יותר גבוהה (k) לצמתים פנימיים. - עקרון גמישות רוחבית: בין k ל 2(k+1)/ (t t-1) - שימוש בדיסקים - הפקטור שמכתיב את k הינו גודל הדף. - ניתן ליישם ווריאציה שבה הערכים רק בעלים, או ווריאציה שבה יש ערכים בצמתים פנימיים. - כנ”ל לגבי עצי חיפוש בינאריים. Data Structures, CS, TAU
20
יישום CLR דוגמה: דוגמה :Insert(j) - מטפל בדרגה כללית.
- מטפל בדרגה כללית. - מטפל בוורסיה שבה המפתחות שוכנים בכל העץ (לא רק בעלים) - מס’ המפתחות נעים בין k-1 ל 2k-1 דוגמה: n i h, f, b a, m, l, k d פעולה בסיסית ב Insert SPLIT אם מס’ המפתחות = 2k-1 פצל לשני צמתים, כ”א עם k-1 והעבר ערך אחד לאבא (החציון). דוגמה :Insert(j) n f b a, m, l, k d h i, j Data Structures, CS, TAU
21
קבוצות עם MERGE ו-FIND - קבוצות של קבוצות.
- מאחדים קבוצות זרות ורוצים לדעת היכן כל עצם. - פעולות MERGE ו FIND - דוגמה: יחס האקוויולנטיות/שקילות (EQUIVALENCE) מקיים: a a רפלקסיבי: a b b a סימטרי: a b, b c a c טרנזיטיבי: נתון: רצף של פעולות שקילות 1 2, , , רוצים: לייצר קבוצות שקילות. משתמשים ב- : MERGE לאיחוד הקבוצות FIND : לחפש למי שקול Data Structures, CS, TAU
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 O(1) : FIND, INIT יעילות: O(N) : MERGE (צריך לעבור על כל אברי המערך) N פעולות MERGE ו- FIND מדד יעילות: Data Structures, CS, TAU
23
יישום מהיר יותר - לקשר את האיברים של A לחוד ושל B לחוד (רשימה מקושרת)
- לא צריך לרוץ על כל אברי התחום אלא רק על אברי הקבוצה. - עדיין n מיזוגים יכולים לעלות: O(n ) 2 כי: רצף של n-1 מיזוגים שבו ממזגים את הקבוצה שנוצרה לאיבר בודד: פתרון: - לשמור את גודל הקבוצות - למזג קבוצות קטנות לגדולות Data Structures, CS, TAU
24
סיבוכיות סיבוכיות: 1) מתחשבנים עם כל איבר בנפרד (לא עם הקבוצה)
2) כשאיבר עובר קבוצה גודל קבוצת האם לפחות מוכפל. 3) גודל קבוצה ראשונית - 1 גודל קבוצה שנייה גודל קבוצה שלישית 4 גודל קבוצה רביעית i-1 גודל קבוצה i 2 אבל גודל הקבוצה האחרונה N 2 #steps גודל קבוצה אחרונה N כל איבר עובר לכל היותר פעמים סבוכיות כוללת Data Structures, CS, TAU
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
26
ביצוע MERGE - בודקים מי הקבוצה הקטנה (נניח A)
- רצים לאורך הקבוצה ומשנים שמה ל- B - באיבר האחרון עושים את השרשור A ל- B - ב Headers מעדכנים את האיבר הראשון ואת גודל הקבוצה. סבוכיות: - כל איבר שעובר לבעלים חדשים, גודל הבעלים גדל פי שניים (לפחות) - לכן כל איבר עובר לכל היותר log n פעמים. סבוכיות : O(n log n) Data Structures, CS, TAU
27
יישום באמצעות עץ - נסיון למנוע ריצה על כל אברי A כשמעבירים ל B-
- בעץ מייצגים איברים. - כל צומת מצביע לאביו. - בשורש יושב שם הקבוצה. A 1 7 3 5 B 8 6 C 17 ביצוע הפעולות: MERGE(A, B) - תלה את השורש של A על זה של B FIND(x) - רוץ כלפי מעלה. Data Structures, CS, TAU
28
סיבוכיות סבוכיות: O(1) = MERGE (יתכן) O(n) = FIND
N שידוכים וחיפושים O(n) 2 (אם תולים גדול על קטן נוצרת רשימה) תלה עץ קטן על גדול שיפור: - בכל תליה עומק גדל ב- 1. - בכל תליה מס’ הצמתים בעץ לפחות מוכפל. - צומת משתתף בתליה עומק כל צומת סבוכיות: Data Structures, CS, TAU
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
30
פונקצית אקרמן: אם כן תולים קטן על גדול, סבוכיות ל N פעולות: O(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 A(x-1, 3) 2 x פעמים A(x, 4) = אין צורה מתמטית Data Structures, CS, TAU
31
פונקציה מונוטונית עולה (לא יורדת) פרקטית חסומה ע”י 4
וריאציה של אקרמן: A(x) = A(x, x) הפונקציה :A(x) A(1) = 2 A(2) = 4 A(3) = 16 A(4) = 2 2 . 65536 פעם : (N) הפונקציה הופכית של :A(x) ה x הקטן ביותר כך ש n A(x) פונקציה מונוטונית עולה (לא יורדת) פרקטית חסומה ע”י 4 Data Structures, CS, TAU
מצגות קשורות
