פעילויות בסיסיות על קבוצות - מושגים אוסף של איברים לעיתים מסודרים לינארית )1 לכל a=b ,a b )2 טרנזיטיביות b>c, a>b : a>c דוגמה

Download Report

Transcript פעילויות בסיסיות על קבוצות - מושגים אוסף של איברים לעיתים מסודרים לינארית )1 לכל a=b ,a b )2 טרנזיטיביות b>c, a>b : a>c דוגמה

‫פעילויות בסיסיות על קבוצות ‪ -‬מושגים‬
‫ אוסף של איברים‬‫ לעיתים מסודרים לינארית‬‫‪ )1‬לכל ‪ a=b ,a<b : a, b‬או ‪a>b‬‬
‫‪ )2‬טרנזיטיביות ‪b>c, a>b‬‬
‫‪: a>c‬‬
‫דוגמה‪ :‬שלמים‪ ,‬ממשיים‪ ,‬אותיות‪.‬‬
‫‪ -‬חברות‪:‬‬
‫‪x‬‬
‫‪A, x A‬‬
‫‪ -‬קבוצה ריקה‪:‬‬
‫ בד”כ אותיות קטנות = איברים‪ ,‬גדולות = קבוצות‬‫‪-x y‬‬
‫חסר משמעות‬
‫‪ -‬תת קבוצה (מוכל)‪A B :‬‬
‫‪1‬‬
‫‪ -‬קבוצת על‪:‬‬
‫‪A ‬‬
‫‪B‬‬
‫‪ -‬הכלה ממש‪:‬‬
‫‪A B‬‬
‫‪ -‬פעולות‪:‬‬
‫‪A B, A B, A–B‬‬
‫‪Data Structures, CS, TAU - 4.1‬‬
‫מבני נתונים אבסטרקטיים לקבוצות‬
UNION (A, B, C)
INTERSECTION (A, B, C)
DIFFERENCE (A, B, C)
MERGE (A, B, C) = disjoint set UNION
)‫(לא מוגדר אם הקבוצות אינן זרות‬
MEMBER (x, A)
MAKENULL (A)
INSERT (x, A)
DELETE (x ,A)
ASSIGN (A, B)
MIN (A)
EQUAL (A, B)
FIND (X)
2
Data Structures, CS, TAU - 4.2
‫ייצוגים של קבוצות‬
(CLR: 12.1 - Direct address Table)
‫ ווקטור ביטים‬.1
‫טוב לקבוצה צפופה‬
Const N
type
SET = packed array[1…N] of boolean
:‫יתרונות‬
DELETE, MEMBER, INSERT = O(1)
UNION, INTERSECTION, DIFF = O(N)
‫ גודלה של הקבוצה האוניברסלית‬N
INTEGERS-‫ מאברי התחום ל‬MAPPING ‫ נבצע‬:‫ עבור קבוצה כללית‬‫ אם הקבוצה אינה צפופה‬:‫חסרונות‬
3
Data Structures, CS, TAU - 4.3
‫ייצוגים של קבוצות (המשך)‬
‫‪ )2‬רשימה מקושרת‬
‫ אין בעיות של גודל קבוצה‬‫ האיברים לא צריכים להיות תת קבוצה של קבוצה אוניברסלית סופית‪.‬‬‫‪ -‬ביצוע איחוד‪ ,‬חיתוך‪ ,‬וחיסור‪:‬‬
‫אם הרשימות אינן ממוינות ‪-‬‬
‫)‪O(N2‬‬
‫אם ממויינות‪:‬‬
‫ למצוא איבר בודד‪:‬‬‫ למצוא ‪ N‬איברים‪:‬‬‫‪ -‬אבל כולם ביחד‪:‬‬
‫) ‪O( N‬‬
‫)‪O(N2‬‬
‫) ‪O( N‬‬
‫‪4‬‬
‫‪Data Structures, CS, TAU - 4.4‬‬
‫ייצוגים של קבוצות (המשך)‬
‫השיטה‪ :‬ריצה משולבת על שתי הרשימות‪ .‬כל פעם מקדמים את הקטן‪.‬‬
‫אחרת‬
‫טיפול זנבות‪:‬‬
‫חיתוך‪ :‬הכנס לחיתוך וקדם שניהם‬
‫קדם הקטן‬
‫השמט‬
‫איחוד‪ :‬הכנס לאחוד וקדם שניהם‬
‫קדם קטן והכנס לאחוד‬
‫צרף‬
‫חיסור‪ :‬קדם שניהם‬
‫קדם קטן (הכנס)‬
‫צרף (השמט)‬
‫זהים‬
‫סיבוכיות ‪ :O(N) -‬כי בכל פעולה מתקדמים באחד‬
‫‪5‬‬
‫‪Data Structures, CS, TAU - 4.5‬‬
‫מילון‬
‫מבנה נתונים להחזקת קבוצות שבו רוצים‬
INSERT, DELETE, MEMBER
7
Data Structures, CS, TAU - 4.6
‫יישום המילון‬
‫‪ )1‬רשימה מקושרת‬
‫‪ – Bit Vector )2‬מאוד יעיל אם התחום מוגבל וקטן‬
‫‪ )3‬מערך ‪ -‬טוב רק אם אין הרבה דינמיות (שינוי מבנה)‬
‫אם לא ממויין‪:‬‬
‫אם ממויין‪:‬‬
‫)‪INS = O(1‬‬
‫)‪INS = O(N‬‬
‫)‪DEL = O(N‬‬
‫)‪DEL = O(N‬‬
‫)‪MEM = O(N‬‬
‫)‪MEM = O(logN‬‬
‫‪8‬‬
‫‪Data Structures, CS, TAU - 4.7‬‬
‫‪ HASH TABLE‬ליישום המילון‬
‫יישום מערך (‪- O(N‬‬
‫ווקטור ביטים )‪ - O(1‬אבל מוגבל בגודל‪.‬‬
‫ ‪ HASH‬בממוצע זמן קבוע ואין מגבלת גודל כמו בווקטור הביטים‪.‬‬‫‪ HASH‬פתוח‪(Chaining) :‬‬
‫ נחזיק ‪ B‬סלים שבהם נאחסן את האיברים )‪(Buckets‬‬‫ גישה לכל סל ב‪ O(1) -‬חפוש בסל לינארי‪.‬‬‫‪- Overflow‬ברשימות‬
‫‪0‬‬
‫‪1‬‬
‫פונקצית ‪:Hash‬‬
‫‪B-1‬‬
‫עבור כל ערך ‪ h(x) , x‬הוא ערך הפונקציה ונופל בתחום ‪.0, 1, …B-1‬‬
‫הכנסת איבר‪:‬‬
‫‪ )1‬חישוב‪h(x)o‬‬
‫‪ )2‬הכנסתו ברשימה המתאימה‬
‫‪9‬‬
‫‪Data Structures, CS, TAU - 4.8‬‬
)Open Addressing( ‫סגור‬HASH
‫משתמשים רק בטבלה‬
) Overflow ‫(בלי רשימות‬
0
1
Bucket Table
B-1
:‫ גורמת התנגשות‬h(x) ‫אם‬
h3(x) ‫( ואח”כ‬rehash) h2(x) ‫מחשבים‬
: Linear Hashing ‫דוגמה פשוטה‬
Hi(x) = (h(x)+i) mod B
0
1
2
3
4
5
6
a b c d e f
3 4 2 3 6 0
f
c
a
b
d
e
10
Data Structures, CS, TAU - 4.9
‫בדיקת חברות (‪ )MEMBER‬ב‪ HASH-‬סגור‬
‫‪ -‬בדוק ‪ h1(x), h2)x(…o‬והשווה את האיבר הנמצא עם ‪x‬‬
‫ בדיקה עד שנמצא “ריק” (צריך ערך ל”ריק”)‬‫‪ -‬אם השמטות אסורות בישום‪ ,‬אזי ריק‬
‫‪ x‬איננו‪.‬‬
‫‪ -‬אבל‪ :‬אם השמטות מותרות‪ :‬ריק‬
‫איננו!‬
‫דוגמה‪:‬‬
‫)‪Ins (a, 1), Ins (b, 1), Ins (c, 1‬‬
‫)‪Del (b‬‬
‫)‪Member (c‬‬
‫נצטרך לסמן ”‪ “deleted‬במקום שהושמט‬
‫א) בחיפוש של איבר ‪ -‬לפסוח עליו‬
‫ב) בהכנסה ‪ -‬ניתן להשתמש בו‬
‫‪11‬‬
‫‪Data Structures, CS, TAU - 4.10‬‬
‫‪a‬‬
‫‪b‬‬
‫‪c‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫ביצועים של ‪ Hash‬פתוח (‪)Chaining‬‬
‫נתון‪:‬‬
‫‪ B‬סלים‬
‫‪ N‬איברים‬
‫‪ = load factor‬‬
‫‪N/B‬‬
‫נניח‪ :‬הכנסה של כל איבר פעם אחת‬‫בממוצע יש בכל סל ‪ N/B‬איברים‬‫)‬
‫)‬
‫‪B‬‬
‫‪N‬‬
‫‪1‬‬
‫‪‬‬
‫(‬
‫‪N‬‬
‫(‬
‫‪‬‬
‫לכן כל ‪ N/2‬האיברים האחרונים דורשים כל‪-‬אחד כ‪1+N/B -‬‬‫פעולות (הכנסת איבר לרשימה ממוינת)‬
‫וסה”כ כל ‪ N‬האיברים דורשים‪:‬‬
‫‪ -‬אזי אם‬
‫‪N B‬‬
‫אם חיפוש בשכיחות דומה‪:‬‬
‫))‬
‫‪B‬‬
‫סה”כ‬
‫‪ ( N ( 1 N‬‬
‫) ‪( N‬‬
‫)]‬
‫‪B‬‬
‫‪ ( N [ 1 N‬‬
‫‪12‬‬
‫‪Data Structures, CS, TAU - 4.11‬‬
‫ביצועים של ‪ Hash‬פתוח (‪ - )Chaining‬המשך‬
‫הנחות‪:‬‬
‫‪:SIMPLE UNIFORM HASHING (1‬‬
‫לכל מפתח יש אותה הסתברות ליפול בכל תא אחרי שהופעלה‬
‫עליו פונקצית ה ‪ HASH-‬ללא תלות במפתחות אחרים‪.‬‬
‫‪ )2‬פונקצית ‪ HASH‬מחושבת ב )‪ O(1‬זמן‪.‬‬
‫‪‬‬
‫בפונקציות ‪ HASH‬ההגדרה “לכל מפתח יש אותה הסתברות ליפול‬
‫בכל תא" אינה במובן של מפתח (ערך) ספציפי‪ ,‬כי‪:‬‬
‫עבור פונקציה נתונה מפתח נתון ייפול בדיוק בתא אחד!‬
‫‪‬‬
‫הגדרה שכן תופסת‪:‬‬
‫לכל התאים‬
‫לכל מפתח ‪k‬‬
‫‪Prob(h(k)=j) = 1/B‬‬
‫‪J= 0, 1, …B-1‬‬
‫‪1‬‬
‫‪P k)(  j0,1,. B1‬‬
‫‪kh(: k)j B‬‬
‫כלומר‪ :‬עבור מפתח אקראי ההסתברות ליפול בכל תא הינה‬
‫‪13‬‬
‫‪Data Structures, CS, TAU - 4.12‬‬
‫‪1‬‬
‫‪B‬‬
‫דוגמאות לפונקציות ‪HASH‬‬
‫‪ )1‬אם‬
‫‪:1‬‬
‫‪0k ‬‬
‫אז ‪ h(k) = k B‬מקיימת את הנחה (‪)1‬‬
‫‪ )2‬אם ‪ k‬מספרים שלמים‪:‬‬
‫‪( h(k) = k mod B‬עדיף לקחת ‪ B‬ראשוני)‬
‫)‪h(k) = B (kA mod 1‬‬
‫‪ )3‬אם ‪ k‬שלמים‪:‬‬
‫‪B‬ראשוני ‪,‬‬
‫החלק השבור של ‪kA‬‬
‫‪0<A<1‬‬
‫‪ Knuth‬ממליץ‪:‬‬
‫‪0.5180 ...‬‬
‫)‪5 1‬‬
‫‪2‬‬
‫(‪A‬‬
‫‪14‬‬
‫‪Data Structures, CS, TAU - 4.13‬‬
‫‪UNIVERSAL HASHING‬‬
‫ משתמש “זדוני” יכול לבחור ‪ n‬מפתחות‪ ,‬כולם לתוך אותו סל‪.‬‬‫ממוצע זמן חיפוש‬
‫) ‪( n‬‬
‫ נכון עבור כל פונקצית ‪ Hash‬קבועה‪.‬‬‫ דרך מניעה יחידה‪:‬‬‫בחירת פונקציה באקראי לא תלויה במפתחות‪.‬‬
‫ בגלל אקראיות האלגוריתם יתנהג שונה בכל ריצה (על אותו ‪) input‬‬‫ ‪ input‬מסויים אינו יכול “לסבול” באופן תמידי‪.‬‬‫‪ -‬עבור כל ‪ input‬ההסתברות לבצועים גרועים קטנה (וזהה לקלטים אחרים דומים)‬
‫‪15‬‬
‫‪Data Structures, CS, TAU - 4.14‬‬
‫‪ - UNIVERSAL HASHING‬המשך‬
‫‪ H -‬אוסף סופי של פונקציות ‪ Hash‬שממפות תחום ‪ U‬ל ‪ B‬סלים }‪{0, 1,…B-1‬‬
‫‪ H‬נקרא אוניברסלי אם‪:‬‬
‫‪ h ‬כל ש )‪ h(x )=h(y‬הינו ‪|H| / B‬‬
‫‪ x, y ‬מספר הפונקציות ‪H‬‬
‫לכל ‪U‬‬
‫כלומר‪ :‬אם פונקציה נבחרת אקראית מ‪H -‬‬
‫אזי סיכוי ההתנגשות של ‪ x‬ו ‪ y‬הינו ‪1/B‬‬
‫משפט‬
‫אם ‪ h‬נבחרת מאוסף אוניברסלי של פונקציות ‪ hash‬ומשמשת להכניס‬
‫‪N‬‬
‫‪ N‬מפתחות לתוך טבלה בגודל ‪B ,B,‬‬
‫אזי תוחלת מס’ ההתנגשויות הקשורות במפתח ‪ x‬הינה קטנה מ ‪.1‬‬
‫‪16‬‬
‫‪Data Structures, CS, TAU - 4.15‬‬
‫הוכחת המשפט‬
‫הוכחה‪:‬‬
‫יהי‪:‬‬
‫אם ‪ z, y‬מתנגשים‬
‫‪1‬‬
‫‪=Cyz‬‬
‫אחרת‬
‫לכן‪:‬‬
‫‪0‬‬
‫‪E[Cyz] = 1‬‬
‫‪B‬‬
‫)כי ‪ z, y‬מתנגשים בהסתברות‬
‫‪1‬‬
‫‪B‬‬
‫)‬
‫יהי ‪ Cx‬מס’ ההתנגשויות הכולל של ‪X‬‬
‫אזי‪:‬‬
‫‪1‬‬
‫‪E [ Cx ]  E [ Cxy ]( N 1) 1‬‬
‫‪B‬‬
‫‪y x‬‬
‫‪17‬‬
‫‪Data Structures, CS, TAU - 4.16‬‬
‫בחירת קבוצה אוניברסלית‬
‫ בחר ‪ B‬ראשוני‪.‬‬‫‪ -‬פרק ‪ x‬ל ‪ r+1‬בתים‬
‫)‪x=(x0, x1,…xr‬‬
‫ דרישה‪ :‬ערך כל ‪ byte‬קטן מ‪B-‬‬‫ יהי } ‪ a={a0, …ar‬רצף של אברים נלקחים‬‫}‪{0, 1,…B-1‬‬
‫באקראי מהקבוצה‬
‫‪ha ‬‬
‫ונגדיר‪H :‬‬
‫‪r‬‬
‫‪ha ( x )(  ai xi ) mod B‬‬
‫‪i 0‬‬
‫‪H Br 1‬‬
‫‪18‬‬
‫‪Data Structures, CS, TAU - 4.17‬‬
‫} ‪H  { ha‬‬
‫‪a‬‬
‫משפט‬
‫האוסף ‪ H‬הוא אוסף אוניברסלי של פונקציות ‪Hash‬‬
‫הוכחה‪:‬‬
‫‪x ‬‬
‫ ניקח שני מפתחות שונים כלשהם ‪y‬‬‫בלי הגבלת הכלליות נניח ‪x0 y0‬‬‫‪-‬נסתכל על בחירה שרירותית של ‪a1, a2,…ar‬‬
‫טענה‪ :‬עבור הבחירה הנ”ל ישנו בדיוק ‪ a0‬בודד המקיים )‪h(x)=h(y‬‬
‫הוכחה‪ :‬כדי שיתקיים )‪ h(x)=h(y‬חייב להתקיים‪:‬‬
‫‪r‬‬
‫) ‪a0 ( x0  yo )  ai ( xi  yi )(mod B‬‬
‫‪i 1‬‬
‫‪a0w z‬‬
‫אבל ‪ B‬הוא ראשוני ולכן יש ‪0  a0  B‬‬
‫יחידי הפותר את המשוואה ‪a0w=z‬‬
‫וזה נכון כי אם ‪ a0’w=z, a0w=z‬אז‬
‫‪(a0-a0’(w=0 mod B‬בניגוד לראשוניות של ‪B‬‬
‫‪19‬‬
‫‪Data Structures, CS, TAU - 4.18‬‬
‫המשך ההוכחה‬
‫ לכן יש בדיוק‪ B r‬ערכים של }‪ {a0, …ar‬שעבורם ‪ x‬ו ‪ y‬מתנגשים לכל (‪)x,y‬‬‫‪ -‬היות ומס’ הערכים של }‪ a={a0, …an‬הוא בדיוק ‪Br1‬‬
‫‪ x‬ו‪ y-‬מתנגשים בדיוק בהסתברות‪:‬‬
‫‪1‬‬
‫‪B‬‬
‫‪Br 1‬‬
‫‪ H‬אוניברסלית‬
‫‪20‬‬
‫‪Data Structures, CS, TAU - 4.19‬‬
‫‪Br‬‬
‫הערכת ביצועים ‪ Hash‬סגור (‪)OPEN ADDRESSING‬‬
‫ ‪ B‬סלים‬‫ ‪ N‬איברים (כרגע בטבלה)‬‫‪ Hash‬לינארי‪:‬‬
‫אם התנגשנו‬
‫סיכוי התנגשות שניה גבוה (כבר נפלנו באזור “מועד”)‬
‫נניח‪ :‬פונקצית ‪ rehash‬שולחת בצורה אקראית‪.‬‬
‫“אמונה”‪ :‬זה הטוב ביותר‬
‫‪21‬‬
‫‪Data Structures, CS, TAU - 4.20‬‬
‫ המשך‬- ‫הערכת ביצועים‬
N
N
N
:‫הסתברות לפחות להתנגשות אחת‬
B
B
B
 N 1
 N 1
( N
:‫הסתברות לפחות לשתי התנגשויות‬
B 1
B 1
B
... N i 1
B i 1
:‫ התנגשויות‬i ‫הסתברות לפחות ל‬
)i
:‫ גדולים‬N, B ‫עבור‬

1
  iPr[ i failures ]
‫הצלחה‬
i 1


 Pr[ i failures ]  Pr[ At least i failures ]
i1
i1
:‫ממוצע‬
:‫אבל‬
N

1  ( N )i 1 B
B
B
N
B N
1

i 1
B
22
Data Structures, CS, TAU - 4.21
‫ המשך‬- ‫הערכת ביצועים‬
:‫ב‬
N ( N 1)...( N i 1)
B 1
(N
)i ‫אם נדייק ונחליף‬
B
B ( B 1)...( B i 1)
‫חשבון מסובך ייתן‬
B 1 N
:1, 2,…M ‫כמה עולה להכניס האיברים‬
M 1
1
B1

M
B1 N
N 0
:‫בממוצע‬
M 1
B
1
d xB [ ln Bln (BM 1) ]

M
B x
M
0
B
M
ln( B
B  M 1
)
23
Data Structures, CS, TAU - 4.22
‫הערכת ביצועים ‪ -‬המשך‬
‫למלא את הטבלה יקח‪ logB :‬בממוצע לאיבר‬
‫אבל למלא ‪(M=0.9B) : 90%‬‬
‫‪10/9 ln10‬‬
‫כלומר‪:‬‬
‫ מילוי הטבלה – פונקציה ‪B‬‬‫‪ -‬כל שבר שונה מ‪ – 1 -‬לא תלויים ב‪B-‬‬
‫בדיקת חברות‬
‫ לאיבר שלא קיים ‪ -‬כמו הכנסה‬‫ לאיבר שקיים ‪ -‬כמו הממוצע עד כה‬‫קיים‪:‬‬
‫‪B  M 1‬‬
‫לא קיים‪:‬‬
‫‪ln B‬‬
‫‪M‬‬
‫‪B‬‬
‫‪‬‬
‫‪B 1 M‬‬
‫‪24‬‬
‫‪Data Structures, CS, TAU - 4.23‬‬
‫‪B 1‬‬
‫הערכת ביצועים ‪ -‬המשך‬
‫הערה‪:‬‬
‫אם ‪ M‬אחוז ( ‪ )‬של ‪ – B‬אזי יעילות הכנסה היא‪:‬‬
‫‪1‬‬
‫‪ln 1‬‬
‫‪‬‬
‫‪1‬‬
‫‪B B‬‬
‫‪ln B‬‬
‫לא תלוי ב‪!!!B-‬‬
‫כלומר‪:‬‬
‫למלא ‪ 90%‬מ ‪1000‬‬
‫למלא ‪ 90%‬מ‪109 -‬‬
‫אבל למלא הכל‬
‫שווה!!‬
‫‪lnB‬‬
‫סיבה‪ :‬השבריר האחרון של המילוי שבו אורך השרשרות‬
‫פרופורציונלי למספר הסלים – קובע‪.‬‬
‫‪25‬‬
‫‪Data Structures, CS, TAU - 4.24‬‬
‫‪1‬‬
‫‪‬‬
‫פתרון התנגשויות ‪Rehash‬‬
‫‪ )1‬לינארי‪:‬‬
‫‪)2‬‬
‫)‪hi(x) = h(x) + i (mod B‬‬
‫בעייתי כי גורם התקבצות‪.‬‬
‫)‪hi(x) = h(x) + C i (mod B‬‬
‫אם ‪ B‬מתחלק ב ‪( C‬או גורם משותף)‬
‫דוגמא ‪B=50‬‬
‫‪: C=20‬‬
‫גרוע מאוד מכיוון שיחזור על עצמו!!!‬
‫‪Ci = 20, 40, 10, 30, 50, 20...‬‬
‫לכן‪ :‬צריך ש ‪ B‬ו ‪ C‬בלי גורם משותף‪.‬‬
‫אבל ‪ -‬תופעת ההתקבצות לא נפתרת‪.‬‬
‫סיבה‪ :‬התקבצות נובעת מכך ש ‪ hi‬מחושבת כפונקציה של המקום בטבלה ולא‬
‫של מס’ ההתנגשויות )‪ – (i‬כל מי שנופל על אותו תא מקבל את אותה ]!! ‪[hi‬‬
‫‪26‬‬
‫‪Data Structures, CS, TAU - 4.25‬‬
‫פתרון התנגשויות ‪ - Rehash‬המשך‬
‫‪ )3‬יותר טוב‪:‬‬
‫)‪hi(x) = h(x) + di (mod B‬‬
‫כש ‪ di‬הינו פרמוטציה של‬
‫דוגמא ‪: B=5‬‬
‫‪1, 2, … B-1‬‬
‫‪d1=4, d2=1, d3=2, d4=3‬‬
‫מונע שכל מי שנופל על )‪ h(x‬יפול באותה השרשרת‪.‬‬‫( כמובן לא מונע שבעלי )‪ h(x‬זהה יפלו על שרשרת זהה! )‬
‫הערה‪ :‬סתם פרמוטציה אינה טובה‪.‬‬
‫לדוגמא‪:‬‬
‫‪d1=1, d2=2, d3=3, d4=4‬‬
‫‪27‬‬
‫‪Data Structures, CS, TAU - 4.26‬‬
‫רה‪-‬ארגון‬
‫‪ -‬טבלה מלאה בעיה‬
‫רה‪-‬ארגון‬
‫כשמבנה הנתונים מתמלא (חוקי אצבע)‪:‬‬
‫טבלה פתוחה‪:‬‬
‫אם ‪ N2B‬כדאי להכפיל הגודל ולהעתיק‪.‬‬
‫טבלה סגורה‪:‬‬
‫אם ‪N > 0.9B‬‬
‫במקרה של ‪ DELETIONS‬כשכמות‬
‫המקומות הפנויים קטן‬
‫]‪[0.1B‬‬
‫‪28‬‬
‫‪Data Structures, CS, TAU - 4.27‬‬
‫תורי עדיפויות ‪PRIORITY QUEUES‬‬
‫)‪(CLR CH7, pp140‬‬
‫קבוצות עם הפעולות‪:‬‬
‫‪INSERT‬‬
‫‪DELETEMIN‬‬
‫דוגמה‪ :‬תור שבו נכנסות פעולות לפי סדר‪ ,‬אבל יוצאות לא ב ‪ FIFO‬אלא לפי עדיפות‪.‬‬
‫“דוגמה מהחיים”‪ :‬ג’ובים במחשב (עם עדיפויות שונות)‬
‫יישומים‪:‬‬
‫‪ )1‬רשימה מקושרת לא מסודרת‬
‫הכנסה )‪:O(1‬‬
‫שליפה )‪:O(N‬‬
‫‪ )2‬רשימה מקושרת מסודרת‬
‫הכנסה )‪:O(N‬‬
‫שליפה )‪:O(1‬‬
‫‪29‬‬
‫‪Data Structures, CS, TAU - 4.28‬‬
‫)‪(N/2‬פעולות‬
‫עץ מוסדר חלקית ‪HEAP‬‬
‫עץ בינארי‪ ,‬מאוזן ככל האפשר‬
‫(רק ברמה התחתונה חסרים)‪.‬‬
‫הורה קטן מילדיו‬
‫דוגמה‪:‬‬
‫‪3‬‬
‫‪5‬‬
‫‪10‬‬
‫‪13‬‬
‫‪15‬‬
‫‪6‬‬
‫‪10.5‬‬
‫‪12‬‬
‫שימו לב‪ :‬אין קשר בין צומת לדודיו!!!‬
‫(למשל‪)10 – 8 ,‬‬
‫‪30‬‬
‫‪Data Structures, CS, TAU - 4.29‬‬
‫‪11‬‬
‫‪9‬‬
‫‪8‬‬
‫ביצוע ‪INSERT‬‬
‫‪ .1‬הוסף הערך החדש ב”סוף העץ”‬
‫‪ .2‬עדכן מבנה העץ ע”י הצפת הערך החדש כלפי מעלה‬
‫השווה אותו עם אביו והחלף אם קטן ממנו‬
‫‪ -‬עד שהעץ “מיושב”‬
‫טענה אינדוקטיבית‪:‬‬
‫בכל רגע כל צומת (פרט למוכנס) גדול מכל אבותיו הקדמונים‪.‬‬
‫‪3‬‬
‫‪5‬‬
‫‪10‬‬
‫‪13‬‬
‫‪15‬‬
‫‪7‬‬
‫‪6‬‬
‫‪10.5‬‬
‫‪12‬‬
‫‪11‬‬
‫‪9‬‬
‫‪31‬‬
‫‪Data Structures, CS, TAU - 4.30‬‬
‫‪8‬‬
‫ביצוע ‪DELETEMIN‬‬
‫‪ .1‬החזר את ערך השורש‪.‬‬
‫‪ .2‬החלף השורש עם העלה האחרון והשמט עלה אחרון‪.‬‬
‫‪" .3‬השקע” את השורש כלפי מטה עד שהעץ יהיה “נורמלי‪”.‬‬
‫בהשקעה ‪ -‬החלף עם הבן הקטן ביותר‪.‬‬
‫‪12‬‬
‫‪3‬‬
‫‪5‬‬
‫‪10‬‬
‫‪15‬‬
‫‪13‬‬
‫‪6‬‬
‫‪10.5‬‬
‫‪12‬‬
‫‪11‬‬
‫‪32‬‬
‫‪Data Structures, CS, TAU - 4.31‬‬
‫‪9‬‬
‫‪8‬‬
‫ביצוע ‪DELETEMIN‬‬
‫בהשקעה ‪ -‬החלף עם הבן הקטן ביותר‪.‬‬
‫‪5‬‬
‫‪3‬‬
‫‪12 5‬‬
‫‪10‬‬
‫‪15‬‬
‫‪13‬‬
‫‪6‬‬
‫‪10.5‬‬
‫‪12‬‬
‫‪11‬‬
‫‪33‬‬
‫‪Data Structures, CS, TAU - 4.31‬‬
‫‪9‬‬
‫‪8‬‬
DELETEMIN ‫ביצוע‬
5
6
12
8
3
5
10
6
10.5
9
11
13
15
12
34
Data Structures, CS, TAU - 4.31
DELETEMIN ‫ביצוע‬
5
6
8
12
8
3
5
10
6
10.5
9
11
13
15
12
35
Data Structures, CS, TAU - 4.31
‫יישום העץ‬
‫נוח ליישם במערך‬
‫עץ כמעט מלא‬
‫שבו ‪ i‬הוא אב של ‪ 2i‬ושל ‪2i+1‬‬
‫ביישום זה‪:‬‬
‫ (שורש)‪ MIN‬נמצא ב‪A[1] -‬‬‫ עלה אחרון נמצא ב‪A[Last] -‬‬‫ אינפורמציה משפחתית ע”י הכפלה‪/‬חלוקה ב‪.2 -‬‬‫סבוכיות הפעולות‪:‬‬
‫עץ בינארי ‪ -‬עומקו‬
‫מס’ הצמתים הינו‬
‫‪lo g2 N‬‬
‫‪N 2n11‬‬
‫לכן סיבוכיות של ‪INSERT, DELETEMIN‬‬
‫היא ‪O (lo g N ) :‬‬
‫‪2‬‬
‫‪36‬‬
‫‪Data Structures, CS, TAU - 4.32‬‬
‫שימושים‬
‫מיון איברים‬
‫‪ -‬הכנס ‪ N‬איברים‬
‫)‪O(NlogN‬‬
‫‪ -‬בצע ‪ DELETEMIN‬של ‪ N‬איברים‬
‫)‪O(NlogN‬‬
‫תור עדיפויות דינאמי‪.‬‬
‫‪37‬‬
‫‪Data Structures, CS, TAU - 4.33‬‬
‫יחסים רב‪-‬ערכיים ורבי רשימות‬
‫)‪(Many to Many Relationships & Multilists‬‬
‫דוגמה ליחס רב‪-‬רב ערכי‪:‬‬
‫‪CS103‬‬
‫‪CS104‬‬
‫‪x‬‬
‫‪x‬‬
‫‪CS102‬‬
‫‪CS101‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫‪x‬‬
‫מיפוי בין סטודנטים והקורסים בהם הם משתתפים‪.‬‬
‫‪38‬‬
‫רוצים לדעת בד”כ‪:‬‬
‫לכל קורס ‪ -‬רשימת סטודנטים‬
‫לכל סטודנט ‪ -‬רשימת קורסים‬
‫‪Data Structures, CS, TAU - 4.34‬‬
‫אברהם‬
‫יצחק‬
‫יעקב‬
‫יוסף‬
‫שרה‬
‫רבקה‬
‫רחל‬
‫לאה‬
‫יישום במערך בינארי‬
‫‪HASH‬‬
‫‪CS101 CS102 CS103‬‬
‫‪7 6 5 4 3 2 1‬‬
‫‪1 0 1‬‬
‫‪0 1 0 1‬‬
‫ישום‪:‬‬
‫‪ .1‬האינפורמציה כמטריצה בינארית‪.‬‬
‫‪ .2‬מיפוי משמות למטריצה טבלת)‪(Hash‬‬
‫בעיה‪ :‬דלילות המטריצה‪.‬‬
‫דוגמה‪ 500 :‬קורסים‪ 10,000 ,‬תלמידים‪.‬‬
‫‪39‬‬
‫‪Data Structures, CS, TAU - 4.35‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫אברהם‬
‫יצחק‬
‫יעקב‬
‫פתרון באמצעות ‪Multilist‬‬
‫רשימת‬
‫קורסים‬
‫‪CS103‬‬
‫‪CS102‬‬
‫‪CS101‬‬
‫אברהם‬
‫יצחק‬
‫יעקב‬
‫רשימת סטודנטים‬
‫לשם מציאת האנפורמציה הדרושה‪:‬‬
‫אפשרות א’‪ :‬השתמש באחרון של כל רשימה כדי לפנות חזרה לאבי הרשימה‪.‬‬
‫סבוכיות‪:‬‬
‫למציאת כל הקורסים של סטודנט הלוקח ‪ k‬קורסים נצטרך לרוץ על‪-‬פני ‪ k‬רשימות‪.‬‬
‫אפשרות ב’‪ :‬החזר מצביע מכל רשומת הרשמה לקורס המתאים ולסטודנט המתאים‪.‬‬
‫יישום דומה‪ :‬מטריצה דלילה‪.‬‬
‫‪40‬‬
‫‪Data Structures, CS, TAU - 4.36‬‬
‫מבני נתוני כפולים להגברת היעילות‬
‫במקרים רבים‪ :‬נוח לבצע חלק מהפעולות במבנה אחד וחלק באחר‪.‬‬
‫לעיתים‪ :‬שמירת כמה מבנים תייעל ביצועים‪.‬‬
‫‪41‬‬
‫‪Data Structures, CS, TAU - 4.37‬‬