1. Data Structures Dana Shapira Hash Tables 26/06/07

2. Element Uniqueness Problem Let Determine whether there exist i  j such that x i =x j Sort Algorithm Bucket Sort for (i=0;i<m;i++) T[i]=NULL; for (i=0;i<n;i++){ if (T[x i ]= = NULL) T[x i ]= i else{ output (i, T[x i ]) return; } What happens when n is large or when we are dealing with real numbers?? O(m) O(n) O(m+n)סיבוכיות:

3. Notations: U universe of keys of size |U|, K an actual set of keys of size n, T a hash table of size O(m) Use a hash-function h:U  {0,…,m-1}, h(x)=i that computes the slot i in array T where element x is to be stored, for all x in U. h(k) is computed in O(|k|) = O(1). x1x1 x2x2 x3x3 x4x4 h(x1)h(x1)h(x2)h(x2)h(x4)h(x4)h(x3)h(x3) U h Set of array indices Hash Tables מספר המפתחותn m גדול הטבלה מניחים שזמן החישוב הוא קבוע טבלאות גיבוב

4. Example h:U  {0,…, m-1} h(x)=x mod 10 (what is m?) input: 17,62,19,81,53 Collision: x ≠ y but h(x) = h(y). m « |U|. Solutions: 1. Chaining 2. Open addressing 81 62 53 17 19 1 2 3 7 9 0 4 5 6 8 m=10 פונקצית הגיבוב היא על אם נרצה להכניס את 82 נקבל בעיית התנגשות: 82!=62 but h(82)=h(62)=2 קטן ממש ביחס לגודל היקוםm

5. Collision-Resolution by Chaining 181 6212 53 173757 19 Insert(T,x): Insert new element x at the head of list T[h(x.key)]. Delete(T,x):Delete element x from list T[h(x.key)]. Search(T,x):Search list T[h(x.key)]. שרשור באמצעות רשימה מקושרת חד כיוונית פעולה של הורדת איבר מרשימה -> חד כיוונית

6. Simple Uniform Hashing Any given element is equally likely to hash to any slot in the hash table. The slot an element hashes to is independent of where other elements hash. Load factor: α = n/m (elements stored in the hash table / number of slots in the hash table) Analysis of Chaining המטרה היא שהפונקציה תעמוד תחת ההנחה של פונקצית גיבוב אחידה פשוטה – ההסתברות שאלמנט ייפול בכל תא במערך שווה. יש פיזור אחיד של מפתחות. כמו כן נדרוש ששני איברים שונים בטבלה לא יהיו תלויים במיקום אחד של השני. m = Θ(n) → α=O(1) ואז כל הפעולות ייקחו בממוצע זמן קבוע

7. Analysis of Chaining Theorem: In a hash table with chaining, under the assumption of simple uniform hashing, both successful and unsuccessful searches take expected time Θ(1+α) on the average, where α is the hash table load factor. Proof: Unsuccessful Search: Under the assumption of simple uniform hashing, any key k is equally likely to hash to any slot in the hash table. The expected time to search unsuccessfully for a key k is the expected time to search to the end of list T[h(k)] which has expected length α.  expected time - O(1 + α ) including time for computing h(k). Successful search: The number of elements examined during a successful search is 1 more than the number of elements that appear before k in T[h(k)].  expected time - O(1 + α ) Corollary: If m = O(n), then Insert, Delete, and Search take expected constant time. ניתוח סיבוכיות - שרשור בשני המקרים – חיפוש מוצלח וחיפוש כושל – נקבל סיבוכיות של: Θ(1+α), כאשר ה – 1 משמש לחישוב פונ' הגיבוב עצמה מעבר למקום הבא ברשימהV עוברים על i-1 איברים ומוצאים באיבר ה – i. החלוקה ב – n נעשית כי מדובר בממוצע סיבוכיות: המספר הזה ^ מקיים >4/α וגם <2/ α ומקבלים Θ(1+α)

8. Example: Input = reals drawn uniformly at random from [0,1) Hash function: h(x) =  mx  Often, the input distribution is unknown. Then we can use heuristics or universal hashing. Designing Good Hash Functions מספרים ממשיים המתפזרים באופן רנדומלי על התחום (0,1] פונ' גיבוב אוניברסלית יוריסטיקות יוריסטיקה: רעיון שלא חייב לעבוד בפועל. רעיון אינטואיטיבי שלא חייב לעבוד במקרה הגרוע, אך בד"כ עובד במקרה הממוצע.

9. Hash function: h(x) = x mod m m = 2 k  h(x) = the lowest k bits of x Heuristic: m = prime number not too close to a power of 2 The Division Method לא לוקחים את כל הספרות – מתרחק מהנחת הגיבוב האחיד על הטבלה. לכן לא נבחר m כנ"ל, אלא:

10. Hash function: h(x) =  m (cx mod 1) , for some 0 < c < 1 Optimal choice of c depends on input distribution. Heuristic: Knuth suggests the inverse of the golden ratio as a value that works well: Example: x=123,456, m=10,000 h(x) =  10,000 ·(123,456·0.61803… mod 1)  = =  10,000 ·(76,300.0041151… mod 1)  = =  10,000 ·0.0041151…  =  41.151...  = 41 The Multiplication Method מה שמופיע אחרי הנקודה בשבר ^ הפונק' הזו יותר טובה, מקודם הפונקציה היתה תלויה בגודל הטבלה וכעת תלויה בקבוע c עפ"י קנוט, c כזה יאפשר גיבוב אחיד על פני הטבלה. גודל טבלהמפתח

11. Efficient Implementation of the Multiplication Method w bits p bits * Fractional part Integer part after multiplying by m = 2 p Let w be the size of a machine word Assume that key x fits into a machine word Assume that m = 2 p Restrict ourselves to values of c of the form c = s / 2 w Then cx = sx / 2 w sx is a number that fits into two machine words h(x) = p most significant bits of the lower word h(x) =  m (cx mod 1)  ע"י בחירה מתאימה של קבוע c, ניתן לבצע זאת עם פעולות של ביטים. בסופו של דבר, נסתכל על p הביטים העליונים במילה התחתונה. ניקח: Sx נכנס לכל היותר ב-2 מילות מכונה

12. x = 123456, p = 14, m = 2 14 = 16384, w = 32, Then sx = (76300 ⋅ 2 32 ) + 17612864 The 14 most significant bits of 17612864 are 67; that is, h(x) = 67 x = 0000 0000 0000 0001 1110 0010 0100 0000 s = 1001 1110 0011 0111 0111 1001 1011 1001 sx = 0000 0000 0000 0001 0010 1010 0000 1100 0000 0001 0000 1100 1100 0000 0100 0000 h(x) = 00 0000 0100 0011 = 67 Example h(x) =  m (cx mod 1)  32 bitמפתח הייצוג של 2654435769: הרצף הבינארי של 123456: (די דילגנו, כי לא למדנו ייצוג בינארי של מספרים)

13. Open Addressing h(x)h(x) All elements are stored directly in the hash table. Load factor α cannot exceed 1. If slot T[h(x)] is already occupied for a key x, we probe alternative locations until we find an empty slot. Searching probes slots starting at T[h(x)] until x is found or we are sure that x is not in T. Instead of computing h(x), we compute h(x, i) i -the probe number. זהו הנידסיון להכניס איבר. → בפעם הראשונה i=0 המחיקה לא מתבצעת באופן ישיר. צריך דגל שיסמן – תפוס לצרכי חיפוש אך פנו לצרכי הכנסה. אחרת אם למשל הכנסנו איבר ראשון ב – I ואיבר שני ב – II, ואז מחקנו את האיבר מ – I, לא יהיה לנו איך להגיע לאיבר ב – II. III

14. Linear Probing Hash function: h(k, i) = (h'(k) + i) mod m, where h' is an original hash function. Benefits: Easy to implement Problem: Primary Clustering - Long runs of occupied slots build up as table becomes fuller. דוגמא: h’(x) = k mod7 h’(9) h(16,0) = h’(16) = 2 h(16,1) = (h’(16)+1) mod 7 = 3 (האחד נוסף בגלל הבדיקה) חיסרון: כל מספר חדש יצטרך לדלג – פוגעים בהנחת ההתפלגות האחידה כי נוצרים "בלוקים" בטבלה. מקבלים התאגדות ראשונית ← יתרון: קל להכניס לתאים. פתרון אפשרי (בעמוד הבא) – לקחת קבועים ולעלות בריבוע כדי שלא ייכנס למקום הפנוי הבא. 0 1 29 316 42 5 6

15. Hash function: h(k, i) = (h'(k) + c 1 i + c 2 i 2 ) mod m, where h' is an original hash function. Benefits: No more primary clustering Problem: Secondary Clustering - Two elements x and y with h'(x) = h'(y) have same probe sequence. Quadratic Probing נוצרת התאגדות שניונית

16. Hash function: h(k, i) = (h 1 (k) + ih 2 (k)) mod m, where h 1 and h 2 are two original hash functions. h 2 (k) has to be prime w.r.t. m; that is, gcd(h 2 (k), m) = 1. Two methods: Choose m to be a power of 2 and guarantee that h 2 (k) is always odd. Choose m to be a prime number and guarantee that h 2 (k) < m. Benefits: No more clustering Drawback: More complicated than linear and quadratic probing Double Hashing פתרון נוסף – שתי פונקציות גיבוב חסרון – צורך בשתי פונ' hash h 2 (k)!=0 אחרת לא נגיע לכל המקומות בטבלה i = מס' הדגימה

17. Analysis of Open Addressing Uniform hashing: The probe sequence h(k, 0), …, h(k, m – 1) is equally likely to be any permutation of 0, …, m – 1. Theorem: In an open-address hash table with load factor α < 1, the expected number of probes in an unsuccessful search is at most 1 / (1 – α ), assuming uniform hashing. Proof: Let X be the number of probes in an unsuccessful search. A i = “there is an i-th probe, and it accesses a non-empty slot” הנחה חדשה במקום הנחת הגיבוב הפשוט – הסתברות קבל כל אחד מהמספרים תהיה אחידה (הוכחה בהסתברות – עברנו על זה באופן כללי)

18. Analysis of Open Addressing – Cont. ההסתברות שתא תפוס בבדיקה הראשונה ההסתברות בבדיקה השניה, בהנחה שגילינו תא תפוס ב – A1 ובאופן כללי – התא ה – j תפוס בהנחה ש – 1…..j-1 תפוסים

19. Corollary: The expected number of probes performed during an insertion into an open-address hash table with uniform hashing is 1 / (1 – α). Analysis of Open Addressing – Cont.

20. A successful search for an element x follows the same probe sequence as the insertion of element x. Consider the (i + 1)-st element x that was inserted. The expected number of probes performed when inserting x is at most Averaging over all n elements, the expected number of probes in a successful search is Theorem: Given an open-address hash table with load factor α < 1, the expected number of probes in a successful search is (1/ α ) ln (1 / (1 – α )), assuming uniform hashing and assuming that each key in the table is equally likely to be searched for. Analysis of Open Addressing – Cont.

22. A family  of hash functions is universal if for each pair k, l of keys, there are at most |  | / m functions in  such that h(k) = h(l). This means: For any two keys k and l and any function h chosen uniformly at random, the probability that h(k) = h(l) is at most 1/m. P= (|  | / m )/ |  | =1/m This is the same as if we chose h(k) and h(l) uniformly at random from [0, m – 1]. Universal Hashing גיבוב אוניברסלי. משפחות של פונקציות גיבוב – בוחרים באופן רנדומלי פונ' גיבוב ומבצעים את כל הפעולות איתה. לכל זוג מפתחות, ההסתברות להתנגשות היא 1/m לא עברנו על הוכחות הסיבוכיות בהמשך

23. Analysis of Universal Hashing Theorem: For a hash function h chosen uniformly at random from a universal family , the expected length of the list T[h(x)] is α if x is not in the hash table and 1 + α if x is in the hash table. Proof: Indicator variables: Y x = the number of keys ≠ x that hash to the same slot as x

24. If x is not in T, then |{y  T : x ≠ y}| = n. Hence, E[Y x ] = n / m = α. If x is in T, then |{y  T : x ≠ y} = n – 1. Hence, E[Y x ] = (n – 1) / m < α. The length of list T[h(x)] is one more, that is, 1 + α. Analysis of Universal Hashing Cont.

25. Universal Family of Hash Functions Choose a prime p so that m = p. Let such For each define the hash function as follows:  =  |  | = Example: m=p=253 a=[248,223,101] x=1025=[0,2,1] . בוחרים באופן רנדומלי מספר, המורכב מ – r+1 איברים בתחום 0,……,m-1 לפיזור על הטבלה ↑ זה נכון, כי לוקחים כל אחד מה – a i להיות 0,….,m-1 (סה"כ m), ויש r+1 a i. תחום המפתחות מגרילים מספר a המורכב מ-3 חלקים, כל חלק לכל היותר 255 פה יש טעות, זה לא באמת 1025 בבינארית קצת בינארית: 00000000 = 0 11111111 = 2 8 -1 = 255 אם המפתח הוא 1025: 12 4 8 16 32 64 | 128 256 512 1024 1 0 0 0 0 0 0 | 0 0 0 1(אני לא בטוחה לגבי זה)

26. Universal Family of Hash Functions Theorem: The class  is universal. Proof: Let such that x ≠ y, w.l.o.g For all a 1,…,a r there exists a single a 0 such that For all there exists a single w such that z·w=1(mod m) for m r values The number of hash functions h in , for which h(k 1 ) = h(k 2 ) is at most m r/ m r+1 =1/m למדנו ש – Zp הוא שדה, ולכן לכל מס' שונה מ-0 יש הופכי

27. Universal Family of Hash Functions Choose a prime p so that m < p. For any 1 ≤ a < p and 0 ≤ b < p, we define a function h a,b (x) = ((ax + b) mod p) mod m. Let H p,m be the family H p,m = {h a,b : 1 ≤ a < p and 0 ≤ b < p}. Theorem: The class H p,m is universal. h(k,i) = (h1(k) + ih2(k))mod11 h1(k) = k mod11 h2(k) = k md 5 + 1 (האחד כדי שפונ' הגיבוב השניה תהיה שונה מאפס, אחרת i לא יקודם) דוגמא: insert(133) 97 89 תפוס – משתמשים בפונ' השנייה 39 תפוס – משתמשים בפונ' השנייה h(37,0) = 4 h(67,0) = 1 תפוס! h(67,1) = 4 תפוס! h(67,2) = 1+2x3 = 7 deleted(133) search(189) h(89,0) = 1 h(89,1) 039 1133 2 3 437 5 689 767 8 997 10 מחקנו את 133, ולכן תפוס לצרכי חיפוש

28. Hash tables are the most efficient dictionaries if only operations Insert, Delete, and Search have to be supported. If uniform hashing is used, the expected time of each of these operations is constant. Universal hashing is somewhat complicated, but performs well even for adversarial input distributions. If the input distribution is known, heuristics perform well and are much simpler than universal hashing. For collision-resolution, chaining is the simplest method, but it requires more space than open addressing. Open addressing is either more complicated or suffers from clustering effects. Summary