Linear Probing
Download
Report
Transcript Linear Probing
8 תרגול
Skip Lists
Hash Tables
Skip Lists
• Definition:
– A skip list is a probabilistic data structure where
elements are kept sorted by key.
– It allows quick search, insertions and deletions of
elements with simple algorithms.
– It is basically a linked list with additional pointers
such that intermediate nodes can be skipped.
– It uses a random number generator to make some
decisions.
Skip Lists
• Skip Levels
– Doubly Linked lists S1..Sh, each start at -∞ and end at
∞.
– Level S1 - Doubly linked list containing all the
elements in the set S.
– Level Si is a subset of level Si-1.
– Each element in Level i has the probability 1/2 to be
in level i+1, thus if there are n elements in level S1,
i-1
the expected number of elements in level Si is (n/2) .
– The expected number of levels required is O(log n).
Skip Lists
• Time Complexity
– Search: O(log n) expected
– Insert: search and then insert in O(log n) time –
O(log n) expected
– Delete: search and then delete in O(log n) time –
O(log n) expected
• Memory Complexity
– O(n) expected
(≈ 𝑛 + 𝑛 + 𝑛 + ⋯ +
2
4
𝑛
2log 𝑛
= 2𝑛)
Skip Lists
:דוגמה
שאלה 1
• הסבירו כיצד ניתן לממש את הפונקציה )Select(S,k
המחזירה את האיבר ה kבגודלו בסקיפ ליסט Sעם n
איברים ,בזמן ממוצע של ) .O(log nאילו שינויים עלינו לבצע
בסקיפ ליסט?
תשובה:
נשמור בכל תא pבסקיפ ליסט ערך ) – dis(pמספר הערכים
(כלומר ,מספר התאים ב )S1בינו לבין התא הבא אחריו
בשרשרת .Si
על מנת לבצע חיפוש ,נתחיל ב∞ -ברמה הגבוהה ביותר
ונשמור את המיקום (בהתחלה .)0בכל פעם שנתקדם
בשרשרת נוסיף ) dis(pלמיקום.
אם מספר המקומות שנותרו עד ,dis(p) <kנרד רמה ונמשיך.
1 שאלה
:קוד
Select(S, k)
p ← leftmost and upmost node of S
pos ← 0
for i ← h (the height of S) downto 1
while (pos + p.dis ≤ k)
pos ← pos + p.dis
p ← p.next
if (pos = k)
return p //return the basis of p's tower
else
p ← below(p)
שאלה 1
הדגמה :נבצע ).Search(7,S
pos= 0
7
6
4
1
Question 2
• Write an algorithm that builds a skip list S from the
given BST T with n elements (T can be unbalanced ),
such that
– the worst query time in S will be O(log n).
– The time complexity of the algorithm should be
O(n).
Question 2
Solution:
Build(T, S)
S1inorder(T)
int i1
while (i < log n)
for j1 to |Si|
if (j mod 2 = 0)
link = Si+1.add(Si[j]) //method
returns a pointer to the link added.
link.below = Si[j]
ii+1
Time Complexity:
The inorder traversal is O(n).
The running time of the rest of the algorithm is linear in the
number of elements in the skip list, that is O(n).
The worst query time in such a skip list is O(log n).
This question demonstrates how to construct a deterministic
skip-list from an ordered set of n keys in O(n) time.
Hash Tables
Hash Function
A hash function h maps keys of a given type into
integers in a fixed interval [0,m-1]
Pr ℎ 𝑘𝑒𝑦 = 𝑖 =
Uniform Hash
hash table.
Hash Table
1
𝑚
, where m is the size of the
A hash table for a given key type consists of:
Hash function h: keys-set →[0,m-1]
Array (called table) of size m
Hash Tables
Direct
Addressing
Chaining
K is a set whose elements' keys are in the range
[0,m-1].
Use a table of size m and store each element x in
index x.key.
Disadvantage: when |K| << m → waste of space
h(k) = k mod m (This is an example of a common
hash function)
If h(k) is occupied, add the new element in the
head of the chain at index h(k)
שאלה 3
• נתון :טבלת גיבוב עם m=11ופונקציות גיבוב
• h1(k)=k mod m
))• h2(k)=1+(k mod (m-1
• הכניסו את האיברים הבאים לפי הסדר (משמאל לימין)
22, 1, 13, 11, 24, 33, 18, 42, 31
.aלטבלת גיבוב מבוססת שרשור ,עם פונקציית גיבוב
).h(k)=h1(k
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
/
/
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
/
/
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(22)=0
0
1
2
3
4
5
6
7
8
9
10
/
/
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(22)=0
0
1
2
3
4
5
6
7
8
9
10
22 /
/
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
22 /
/
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(1)=1
0
1
2
3
4
5
6
7
8
9
10
22 /
/
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(1)=1
0
1
2
3
4
5
6
7
8
9
10
22 /
1 /
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
22 /
1 /
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(13)=2
0
1
2
3
4
5
6
7
8
9
10
22 /
1 /
/
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(13)=2
0
1
2
3
4
5
6
7
8
9
10
22 /
1 /
13 /
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
22 /
1 /
13 /
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(11)=0
0
1
2
3
4
5
6
7
8
9
10
22 /
1 /
13 /
/
/
/
/
/
/
/
/
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(11)=0
0
1
2
3
4
5
6
7
8
9
10
11
1 /
13 /
/
/
/
/
/
/
/
/
22 /
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(24)=2
0
1
2
3
4
5
6
7
8
9
10
11
1 /
24
/
/
/
/
/
/
/
/
22 /
13 /
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(33)=0
0
1
2
3
4
5
6
7
8
9
10
33
1 /
24
/
/
/
/
/
/
/
/
11
13 /
22 /
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(18)=7
0
1
2
3
4
5
6
7
8
9
10
33
1 /
24
/
/
/
/
18 /
/
/
/
11
13 /
22 /
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(42)=9
0
1
2
3
4
5
6
7
8
9
10
33
1 /
24
/
/
/
/
18 /
/
42 /
/
11
13 /
22 /
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Chaining
h(k)=k mod 11
h(31)=9
0
1
2
3
4
5
6
7
8
9
10
33
1 /
24
11
13 /
/
/
/
/
18 /
/
31
/
42 /
22 /
Hash Tables
Open
Addressing
Linear Probing:
h(k,i) = (h'(k) + i)mod m 0≤ i ≤ m-1
h'(k) - common hash function
First try h(k,0) = h'(k) , if it is occupied, try h(k,1) etc..
Advantage: simplicity
Disadvantage: clusters, uses Θ(m) permutations of
index addressing sequences
Double Hashing:
h(k,i) = (h1(k) + i·h2(k))mod m 0≤ i ≤ m-1
h1 – hash function
h2 – step function
First try h(k,0) = h1(k), if it is occupied, try h(k,1) etc.
Advantage: less clusters , uses Θ(m*m) permutations
of index addressing sequences
שאלה 3
• נתון :טבלת גיבוב עם m=11ופונקציות גיבוב
• h1(k)=k mod m
))• h2(k)=1+(k mod (m-1
• הכניסו את האיברים הבאים לפי הסדר (משמאל לימין)
22, 1, 13, 11, 24, 33, 18, 42, 31
.aלטבלת גיבוב מבוססת שרשור ,עם פונקציית גיבוב
).h(k)=h1(k
.bלטבלת גיבוב מבוססת ,linear probingעם אותה פונקציית
גיבוב.
.cלטבלת גיבוב מבוססת ,double hashingעם פונקציית
גיבוב ראשית ) h1(kופונקציית צעד ).h2(k
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(22)=0
0
1
2
3
4
5
6
7
8
9
10
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(22)=0
0
1
2
3
4
5
6
7
8
9
10
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(22)=0
0
1
2
3
4
5
6
7
8
9
10
22
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
22
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(1)=1
0
1
2
3
4
5
6
7
8
9
10
22
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(1)=1
0
1
2
3
4
5
6
7
8
9
10
22
1
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
22
1
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(13)=2
0
1
2
3
4
5
6
7
8
9
10
22
1
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(13)=2
0
1
2
3
4
5
6
7
8
9
10
22
1
13
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
0
1
2
3
4
5
6
7
8
9
10
22
1
13
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(11)=0
0
1
2
3
4
5
6
7
8
9
10
22
1
13
תפוס
תפוס
תפוס
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(11)=0
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(24)=2
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
תפוס
תפוס
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(24)=2
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
24
פנוי
שאלה 3
22, 1, 13, 11, 24, 33, 18, 42, 31
תפוס
תפוס
תפוס
תפוס
תפוס
פנוי
22
1
13
11
24
0
1
2
3
4
5
6
7
8
9
10
Linear Probing
h(k)=k mod 11
h(33)=0
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(33)=0
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
24
33
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(18)=7
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
24
33
18
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(42)=9
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
24
33
18
42
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(31)=9
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
24
33
18
42
תפוס
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
Linear Probing
h(k)=k mod 11
h(31)=9
0
1
2
3
4
5
6
7
8
9
10
22
1
13
11
24
33
18
42
31
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(22)=0
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(22)=0
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(22)=0
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(1)=1
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(1)=1
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
1
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
1
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(13)=2
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
1
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(13)=2
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
1
13
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
1
13
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(11)=0
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(11)=2
10
Double
Hashing
22
1
13
תפוס
תפוס
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(11)=0
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(11)=2
10
Double
Hashing
22
1
13
11
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(24)=2
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(24)=5
10
Double
Hashing
22
1
13
תפוס
11
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(24)=2
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(24)=5
10
Double
Hashing
22
1
13
11
24
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(33)=0
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(33)=4
10
Double
Hashing
22
1
13
תפוס
11
תפוס
24
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(33)=0
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(33)=4
10
Double
Hashing
22
1
13
11
24
33
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(18)=7
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(18)=9
10
Double
Hashing
22
1
13
11
18
24
33
פנוי
תפוס
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(42)=9
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
10
Double
Hashing
22
1
13
11
18
24
33
42
פנוי
3 שאלה
22, 1, 13, 11, 24, 33, 18, 42, 31
0
1
2
3
h1(k)=k mod 11
4
h1(31)=9
5
6
7
Step Function
h2(k)=1+ (k mod 10) 8
9
h2(31)=2
10
Double
Hashing
22
1
13
תפוס
11
18
31
24
33
42
תפוס
תפוס
פנוי
תפוס
3 שאלה
Chaining
Linear Probing Double Hashing
0
33 → 11→ 22 22
22
1
1
1
1
2
24 → 13
13
13
3
11
4
24
11
5
33
18
6
7
31
18
18
8
9
10
24
33
31→ 42
42
31
42
:טבלת השוואה
Hash Tables
𝑛
𝑚
𝛼 = , Hash table with m slots that stores n
Load Factor 𝛼 elements (keys)
Open Addressing
unsuccessful search: O(1 +
Average
(expected)
Search Time
successful search: O(1 +
1
)
1−𝛼
1
1
ln
𝛼
1−𝛼
)
Chaining
unsuccessful search: Θ (1 + α)
𝛼
successful search: Θ (1 + ) = Θ (1 + α)
2
!לוח
Hash Tables
הערות חשובות:
• היעילות בטבלאות גיבוב נמדדת בזמן הממוצע ,לא
הגרוע ביותר.
• ה load factorמייצג את מספר המפתחות בממוצע
שמקבלים את אותו ערך בפונקציית הגיבוב.
דוגמא :נסתכל על טבלת גיבוב עם שרשור
–
–
–
–
ה load factorהינו האורך הממוצע של שרשרת בטבלה
אם נסתכל במקרה הגרוע ביותר ,כל המפתחות מקבלים
אותו ערך גיבוב ומושמים באותו תא ,ולכן נוצרת שרשרת
באורך .n
לכן ,במקרה הגרוע ביותר ,זמן החיפוש של מפתח בטבלה
הינו ).(𝜃 𝑛 + 𝑡𝑖𝑚𝑒 𝑡𝑜 𝑐𝑜𝑚𝑝𝑢𝑡𝑒 ℎ𝑎𝑠ℎ
על כן ,ברור שאיננו משתמשים בטבלאות גיבוב עקב
הביצועים בזמן הגרוע ביותר ,וכשננתח זמן בפעולות גיבוב
נחשב לפי המקרה הממוצע.
שאלה 4
• בשאלה 3השתמשנו ,עבור טבלת גיבוב עם
,m=11בפונקציית גיבוב ראשית h1(k)=k mod 11
ופונקציית צעד .h2(k)= k mod 10 + 1
.aהאם ניתן היה להשתמש בפונקציה h1כפונקציית
הצעד ובפונקציה h2כפונקציית הגיבוב?
שאלה 4
h1(k)=k mod 11
h2(k)= k mod 10 + 1
.aהאם ניתן היה להשתמש בפונקציה h1כפונקציית
הצעד ובפונקציה h2כפונקציית הגיבוב?
תשובה:
לא ,כיוון ש) h1(kעלול לקבל ערך ,0ואם התא כבר
תפוס לא נוכל למקם את הערך החדש.
לדוגמא ,אם נכניס את הערך ,1ולאחר מכן ננסה
להכניס את הערך ,11לא נוכל.
בעיה נוספת היא ש h2לא מקבלת את הערך .0
שאלה 4
• בשאלה 3השתמשנו ,עבור טבלת גיבוב עם
,m=11בפונקציית גיבוב ראשית h1(k)=k mod 11
ופונקציית צעד .h2(k)=1 + k mod 10
.aהאם ניתן היה להשתמש בפונקציה h1כפונקציית
הצעד ובפונקציה h2כפונקציית הגיבוב?
.bמדוע חשוב שתוצאת פונקציית הצעד וגודל
הטבלה יהיו זרים? כלומר ,אם hstepהינה
פונקציית הצעד ,מדוע חשוב לדרוש
gcd(hstep(k),m)=1לכל ?k
שאלה 4
.bמדוע חשוב שתוצאת פונקציית הצעד וגודל
הטבלה יהיו זרים? כלומר ,אם hstepהינה
פונקציית הצעד ,מדוע חשוב לדרוש
gcd(hstep(k),m)=1לכל ?k
תשובה :אם gcd(hstep(k),m)=d>1אז ההשמה של k
1
אפשרית רק ב מהתאים .לכן ,ייתכן שלא נוכל
𝑑
למצוא תא פנוי עבור ,kאפילו אם הטבלה אינה
מלאה.
שאלה 4
הדגמה :נניח ש .hstep(k)=2 ,h1(k)=1 ,m=8אז
8
,gcd(hstep(k),m)=2לכן ניתן להכניס את kרק ב
2
= 4תאים אפשריים.
לא אפשרי
אפשרי
לא אפשרי
אפשרי
לא אפשרי
אפשרי
לא אפשרי
אפשרי
0
1
2
3
4
5
6
7
שאלה 4
• 2דרכים להבטיח gcd(hstep(k),m)=1לכל מפתח:
.1גודל הטבלה הוא מספר ראשוני ,ו hstep(k)<mלכל .k
.2גודל הטבלה הוא חזקה של ,(𝑚 = 2𝑥 ) 2ופונקציית
הצעד מחזירה רק תוצאות אי-זוגיות.
שאלה 5
• נתונות שתי קבוצות של מספרים שלמים
} S={s1,s2,…,smו } ,T={t1,t2,…,tnכאשר .m≤n
.aהציעו אלגוריתם דטרמיניסטי לבדיקה האם 𝑇 ⊆ 𝑆
בעל זמן ריצה יעיל במקרה הגרוע ביותר.
שאלה 5
• נתונות שתי קבוצות של מספרים שלמים
} S={s1,s2,…,smו } ,T={t1,t2,…,tnכאשר .m≤n
.aהציעו אלגוריתם דטרמיניסטי לבדיקה האם 𝑇 ⊆ 𝑆
בעל זמן ריצה יעיל במקרה הגרוע ביותר.
קוד:
תשובה:
)Subset(T,S,n,m
)T:=sort(T
ראשית ,נמיין את .T
for each sj S
לאחר מכן נעבור על
)found := BinarySearch(T, sj
האיברים ב Sונחפש
)if (!found
"return "S is not a subset of T
אותם ב Tבאמצעות
"return "S is a subset of T
חיפוש בינארי.
זמן ריצהO(nlog n+mlog n)=O(nlog n) :
שאלה 5
• נתונות שתי קבוצות של מספרים שלמים
} S={s1,s2,…,smו } ,T={t1,t2,…,tnכאשר .m≤n
.aהציעו אלגוריתם דטרמיניסטי לבדיקה האם 𝑇 ⊆ 𝑆
בעל זמן ריצה יעיל במקרה הגרוע ביותר.
.bהציעו אלגוריתם בעל זמן ריצה יותר טוב בממוצע,
ע"י שימוש בטבלת גיבוב בגודל .m
שאלה 5
.bהציעו אלגוריתם בעל זמן ריצה יותר טוב בממוצע,
ע"י שימוש בטבלת גיבוב בגודל .m
תשובה:
ראשית ,נכניס את ערכי Tלטבלת גיבוב (מבוססת
שרשור).
לאחר מכן ,נחפש עבור כל ערך ב Sאם הוא כבר נמצא
בטבלת הגיבוב.
קוד:
)SubsetWithHashTable(T,S,n,m
for each ti T
)insert(HT, ti
for each sj S
)found = search(HT, sj
)if (!found
"return "S is not a subset of T
"return "S is a subset of T
שאלה 5
.bהציעו אלגוריתם בעל זמן ריצה יותר טוב בממוצע ,ע"י
שימוש בטבלת גיבוב בגודל .m
ניתוח זמן הריצה הממוצע:
הכנסת הערכים של Tלטבלת הגיבוב 𝑛 ⋅ 𝑂 1 = 𝑂 𝑛 -
אם 𝑇 ⊆ 𝑆 – במצב זה ישנם mחיפושים מוצלחים .לכן זמן
𝛼
𝑛
𝑚 1+ =𝑚 1+
הריצה הוא 𝑛 = 𝑂 𝑚 +
2
𝑚2
𝑛 𝑂=
אם 𝑇 ⊆ 𝑆 – במקרה הגרוע ביותר ישנם ) (m-1חיפושים
מוצלחים והחיפוש האחרון אינו מוצלח .לכן באופן דומה ,זמן
הריצה הוא
𝛼
𝑚−1 1+
)𝑛(𝑂 = 𝛼 + 1 +
2
שאלה 5
• נתונות שתי קבוצות של מספרים שלמים
} S={s1,s2,…,smו } ,T={t1,t2,…,tnכאשר .m≤n
.aהציעו אלגוריתם דטרמיניסטי לבדיקה האם 𝑇 ⊆ 𝑆
בעל זמן ריצה יעיל במקרה הגרוע ביותר.
.bהציעו אלגוריתם בעל זמן ריצה יותר טוב בממוצע,
ע"י שימוש בטבלת גיבוב בגודל .m
.cבהינתן פילטר בלום בגודל rו kפונקציות גיבוב
] h1,h2,…,hk:U→[rהראו כיצד ניתן לבדוק אם 𝑇 ⊆ 𝑆
בזמן ) O(nבמקרה הגרוע ביותר .מהי ההסתברות
לקבלת false positiveבמקרה זה?
Hash Tables
Bloom
Filter
A Bloom filter model consists of a bit-Array of size
m (the bloom filter) and k hash functions h1, h2, ...,
hk .
It supports insertion and search queries only:
Insert at O(1)
Search(x) in O(1), with 1 − 𝑒
of getting a false positive
𝑛
−𝑘𝑚
𝑘
probability
שאלה 5
.cבהינתן בלום פילטר בגודל rו kפונקציות גיבוב
] h1,h2,…,hk:U→[rהראו כיצד ניתן לבדוק אם 𝑆
𝑇 ⊆ בזמן ) O(nבמקרה הגרוע ביותר .מהי
ההסתברות לקבלת false positiveבמקרה זה?
פתרון:
ראשית ,נכניס את כל האיברים ב Tלבלום פילטר.
לאחר מכן ,עבור כל איבר ב Sנבדוק אם הוא נמצא
בבלום פילטר.
זמן ריצה (:)worst case
nהכנסות ו mחיפושים בבלום פילטר ,לכן 𝑘 𝜃 ⋅ 𝑛
)𝑛(𝜃 = + 𝑚 ⋅ 𝜃 𝑘 = 𝑚 + 𝑛 ⋅ 𝜃 1
שאלה 5
ניתוח סיכוי ל:false positive
עבור כל 𝑆 ∈ 𝑠 ,נוכל לקבל תשובה שגויה רק אם 𝑠
𝑇 ∉ .כלומר ,ייתכן שהבלום פילטר יזהה ש 𝑇 ∈ 𝑠
גם כאשר זה לא המצב ,בהסתברות
𝑘
𝑛
𝑘−
𝑟
𝑒. 1−
האלגוריתם מחזיר שגיאה רק אם טעה בכל האיברים
ב .S\Tכלומר ,אם נסמן | ,x=|S\Tאז האלגוריתם
מחזיר שגיאה בהסתברות
𝑥𝑘
𝑛
𝑘−
𝑟
𝑒. 1−
לחילופין ,אם נסמן | ,t=|S∩Tאז האלגוריתם טועה
בהסתברות
)𝑡𝑘(𝑚−
𝑛
𝑘−
𝑟
𝑒. 1−
שאלה 6
• נתון מערך של מספרים ממשיים וערך כלשהו .X
עליכם למצוא האם קיימים שני ערכים במערך
שסכומם הוא .X
.aהראו כיצד ניתן לעשות זאת ב) O(nlog nבמקרה
הגרוע ביותר
פתרון:
נמיין את המערך .עבור כל ערך ] A[iבמערך ,נבצע
חיפוש בינארי במערך עבור הערך ].X-A[i
סה"כ זמן ריצהO(nlog n) :
שאלה 6
• נתון מערך של מספרים ממשיים וערך כלשהו .X
עליכם למצוא האם קיימים שני ערכים במערך
שסכומם הוא .X
.aהראו כיצד ניתן לעשות זאת ב) O(nlog nבמקרה
הגרוע ביותר.
.bכיצד ניתן לעשות זאת ב) O(nזמן ממוצע?
שאלה 6
.bכיצד ניתן לעשות זאת ב) O(nזמן ממוצע?
פתרון:
.1בוחרים פונקציית גיבוב אוניברסלית hמקבוצת
פונקציות גיבוב אוניברסליות .H
.2מכניסים את ערכי המערך לטבלת גיבוב בגודל n
מבוססת שירשור ע"י פונקציית הגיבוב .h
.3עבור כל ערך ] A[iבמערך ,נבדוק האם ] X-A[iנמצא
בטבלת הגיבוב.
כפי שהראתם בשיעור ,ע"י שימוש בפונקציית גיבוב
אוניברסלית ,זמן החיפוש של ערך בטבלת הגיבוב הינו
) ,O(1ללא תלות בהתפלגות הערכים במערך .לכן זמן
הריצה של האלגוריתם הינו ) O(nבממוצע.
Question 7
• Suppose we have n elements and a very good hash
function. We have a hash table with m=n(1.5) double slots,
that is, each hash table slot can hold two elements.
• We perform insert and search in the obvious manner,
checking both slots if necessary, but we do not implement
any collision resolution as in open addressing.
• Instead, we have an overflow linked list for those elements
that do not fit.
– This list accepts all overflow elements, regardless of where they
come from.
– Clearly, one must search the overflow list after having inspected
a full slot.
• Show that the expected unsuccessful search time is O(1). In
other words, show that the expected number of elements
in the overflow list is O(1)
– (Hint: look at the total number of triples of n elements, and
what is the chance that the hash function takes a triple to the
same slot) .
Question 7
Solution:
• Number of triplets among n indices = Θ(n3)
• The probability for two keys to fall into the
same slot 1/m
• The probability of a triplet to fall into the
same slot 1/m2
• m = n(1.5) so the average number of collisions
which will cause a key to go into the overflow
list is:
• Θ(n3)/m2 = Θ(n3)/n3 = O(1)
שאלה 8
• בטבלת גיבוב מבוססת ,double hashingבכל תא
iבטבלה הוסיפו מונה ,ciהמונה את מספר
המפתחות kשהוכנסו לטבלה עם .h1(k)=i
.aכיצד ניתן להשתמש במונים אלו כדי ליעל את
החיפוש בטבלה ,במקרה של חיפוש לא מוצלח?
שאלה 8
• בטבלת גיבוב מבוססת ,double hashingבכל תא
iבטבלה הוסיפו מונה ,ciהמונה את מספר
המפתחות kשהוכנסו לטבלה עם .h1(k)=i
.aכיצד ניתן להשתמש במונים אלו כדי ליעל את
החיפוש בטבלה ,במקרה של חיפוש לא מוצלח?
תשובה:
נחפש באותו אופן ,אולם נשמור את מספר
המפתחות ’ kעם ) h1(k’)=h1(kשראינו .אם ראינו כבר
ciמפתחות כאלו ,נדע ש) h1(kלא נמצא.
8 שאלה
כיצד ניתן להשתמש במונים אלו כדי ליעל את.a
? במקרה של חיפוש לא מוצלח,החיפוש בטבלה
Search(HT,m,k,h)
.:קוד
index=h(k,0)
c=cindex
i=0
do
if c = 0
return -1
if HT[h(k,i)] is empty
return -1
if HT[h(k,i)] = k
return h(k,i)
else
k'=HT[h(k,i)]
if (h(k',0) = index)
c = c-1
i = i+1
while (i < m)
האם תיתכן שגיאה
אם נשמיט את
?הבדיקה הזאת
שאלה 8
• בטבלת גיבוב מבוססת ,double hashingללא
מחיקות ,בכל תא iבטבלה הוסיפו מונה ,ciהמונה
את מספר המפתחות kשהוכנסו לטבלה עם
.h1(k)=i
.aכיצד ניתן להשתמש במונים אלו כדי ליעל את
החיפוש בטבלה ,במקרה של חיפוש לא מוצלח?
.bהראו דוגמה בה מספר הגישות לטבלה בחיפוש
לא מוצלח יורד מ nל( 2ע"י שימוש בסעיף הקודם)
שאלה 8
דוגמה:
• נסתכל על טבלת גיבוב עם
– m=7
– h1(k)=k mod 7
– )h2(k)=1+(k mod 6
• נכניס את המפתחות הבאים
לפי הסדר (משמאל לימין)
}{ -3, 3, 1, 8, 9, 12,21
• כעת ,חיפוש עבור 29יקח 2
קריאות מהטבלה ,במקום .7
c0=1
c1=2
c2=1
c3=1
c4=1
c5=1
c6=0
8
1
9
3
-3
12
21
0
1
2
3
4
5
6
שאלה 8
• בטבלת גיבוב מבוססת ,double hashingבכל תא
iבטבלה הוסיפו מונה ,ciהמונה את מספר
המפתחות kשהוכנסו לטבלה עם .h1(k)=i
.aכיצד ניתן להשתמש במונים אלו כדי ליעל את
החיפוש בטבלה ,במקרה של חיפוש לא מוצלח?
.bהראו דוגמה בה מספר הגישות לטבלה בחיפוש
לא מוצלח יורד מ nל( 2ע"י שימוש בסעיף הקודם)
.cהאם ניתן להשתמש באלגוריתם הנ"ל גם בטבלת
גיבוב מבוססת ?linear probing
שאלה 8
.cהאם ניתן להשתמש באלגוריתם הנ"ל גם בטבלת
גיבוב מבוססת ?linear probing
תשובה:
כן.
9 שאלה
• In Moshe's grocery store, an automatic ordering system
that uses a Queue (FIFO) is installed. Whenever a client
places an order, the order's data (product, quantity,
client's name) are being inserted to the back of the
Queue.
• Moshe is extracting orders from the front of the queue,
handling them one by one. In order to avoid a scenario
where the store runs out of some product, every time
Moshe extracts an order from the front of the Queue, he
would like to know the total quantity of the currently
extracted product, summed over all of this product's
orders in the Queue.
• Find a data structure that supports the following
operations in the given time:
9 שאלה
1. Enqueue(r)-Inserting an order to the back of the
queue, r = (product, quantity, client's name).
Running time - O(1) on average.
2. Dequeue()-Extracting an order from the front of the
queue. Running time - O(1) on average.
3. Query(p)-Returns the total quantity of the product
p in the Queue - O(1) on average.
• It is known that there are n products in the grocery.
The Queue may hold at most m orders at any given
time. We know that m<n. The data structure may use
O(m) memory.
פתרון- 9 שאלה
• Solution:
• We will use a Queue and a hash table with chaining of size
O(m). Each element (in the linked list) contains a key – the
product's name and another field – its quantity.
• Enqueue(r) – Insert the order to the back of the queue.
Search for r.product in the hash table. If r.product is in the
table, add r.quantity to the quantity field of the appropriate
element. If not, insert r.product to the hash table and
update its quantity.
• Dequeue() – Extract r from the front of the queue. Search
for r.product in the hash table (it must be in it). Decrement
the quantity field of the element by r.quantity. If the
quantity is 0, remove the element from the hash table.
פתרון- 9 שאלה
• Solution:
• Query(p) – Look for p in the hash table. If p is
in the table, return p.quantity else return 0.
Notice that ;
numberOfDifferent Pr oductsInQueue
m
O(1)
SizeOfHashTable
(m)
therefore, the running time of the three
operations is O(1) in average.