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)
S1inorder(T)
int i1
while (i < log n)
for j1 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]
ii+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.