1. Skip List & Hashing
CSE, POSTECH

2. Introduction
The search operation on a sorted array using the binary search method takes O(logn)
The search operation on a sorted chain takes O(n)
How can we improve the search performance of a sorted chain?
By putting additional pointers in some of the chain nodes
Chains augmented with additional forward pointers are called skip lists

3. Dictionary A dictionary is a collection of elements
Each element has a field called key
(key, value)
Every key is usually distinct
Typical dictionary operations are:
Determine whether or not the dictionary is empty
Determine the dictionary size (i.e., # of pairs)
Insert a pair into the dictionary
Search the pair with a specified key
Delete the pair with a specified key

4. Accessing Dictionary Elements
Random Access
Any element in the dictionary can be retrieved by simply performing a search on its key
Sequential Access
Elements are retrieved one by one in ascending order of the key field
Sequential Access Operations:
Begin – retrieves the element with smallest key
Next – retrieves the next element

5. Dictionary with Duplicates
Keys are not required to be distinct
Word dictionary is such an example
Pairs are of the form (word, meaning)
May have two or more entries for the same word
For example, the meanings of the word, rank:
(rank, a relative position in a society)
(rank, an official position or grade)
(rank, to give a particular order or position to)
etc.

6. Application of Dictionary
Collection of student records in a class
(key, value) = (student-number, a list of assignment and exam marks)
All keys are distinct
Get the element whose key is Tiger Woods
Update the element whose key is Seri Pak
Read Examples 10.1, 10.2 & 10.3
Exercise: Give other real-world applications of dictionaries and/or dictionaries with duplicates

7. Dictionary – ADT & Class Definition
See ADT 10.1 for the abstract data type Dictionary
See Program 10.1 for the abstract class Dictionary

8. Dictionary as an Ordered Linear List
L = (e1, e2, e3, …, en)
Each ei is a pair (key, value)
Array or chain representation
unsorted array: O(n) search time
sorted array: O(logn) search time
unsorted chain: O(n) search time
sorted chain: O(n) search time
See Program 10.2 (find), 10.3 (insert), 10.4 (erase) of the class sortedChain

9. Skip Lists
Skip lists improve the performance of insert and delete operations
Employ a randomization technique to determine where and how many to put additional forward pointers
The expected performance of search and delete operations on skip lists is O(logn)
However, the worst-case performance is (n)

10. Dictionary as a Skip List
Read Example 10.4 and see Figure 10.1 for
A sorted chain with head and tail nodes
Adding forward pointers
Search and insert operations in skip lists
For general n, the level 0 chain includes all elements
Level 1 chain includes every second element
Level 2 chain includes every fourth element
Level i chain includes 2ith element
An element is a level i element iff it is in the chains for levels 0 through i

11. Skip List – pointers, search, insert
Figure Fast searching of a sorted chain

12. Skip List – Insertions & Deletions
When insertions or deletions occur, we require O(n) work to maintain the structure of skip lists
When an insertion is made, the pair level is i with probability 1/2i
We can assign the newly inserted pair at level i with probability pi
For general p, the number of chain levels is log1/pn + 1
See Figure 10.1(d) for inserting 77
We have no control over the structure that is left following a deletion

13. Skip List – Assigning Levels
The level assignment of newly inserted pair is done using a random number generator (0 to RAND_MAX)
The probability that the next random number is  Cutoff = p * RAND_MAX is p
The following is used to assign a level number
int lev = 0
while (rand() <= CutOff) lev++;
In a regular skip list structure with N pairs, the maximum level is log1/pN - 1
Read Example 10.5

14. Skip List – Class definition
The class definition for skipNode is in Program 10.5
The data members of the class skipList is defined in Program 10.6
See Program 10.7 – for skipList operations

15. Hash Table
A hash table is an alternative method for representing a dictionary
In a hash table, a hash function is used to map keys into positions in a table. This act is called hashing
The ideal hashing case: if a pair p has the key k and f is the hash function, then p is stored in position f(k) of the table
Hash table is used in many real world applications!

16. Hash Table Hash Table Operations
Search: compute f(k) and see if a pair exists
Insert: compute f(k) and place it in that position
Delete: compute f(k) and delete the pair in that position
In ideal situation, hash table search, insert or delete takes (1)
Read Examples 10.6 & 10.7

17. Ideal Hashing Example Pairs are: (22,a),(33,c),(3,d),(72,e),(85,f)
Hash table is ht[0:7], b = 8 (where b is the number of positions in the hash table)
Hash function f is key % b = key % 8
Where are the pairs stored?
[0] [1] [2] [3] [4] [5] [6] [7]
[0] [1] [2] [3] [4] [5] [6] [7]
(72,e)
(33,c)
(3,d)
(85,f)
(22,a)

18. What Can Go Wrong? - Collision
[0] [1] [2] [3] [4] [5] [6] [7]
(72,e)
(33,c)
(3,d)
(85,f)
(22,a)
Where does (25,g) go?
The home bucket for (25,g) is already occupied by (33,c)
 This situation is called collision
Keys that have the same home bucket are called synonyms
25 and 33 are synonyms with respect to the hash function that is in use

19. What Can Go Wrong? - Overflow
A collision occurs when the home bucket for a new pair is occupied by a pair with different key
An overflow occurs when there is no space in the home bucket for the new pair
When a bucket can hold only one pair, collisions and overflows occur together
Need a method to handle overflows
[0] [1] [2] [3] [4] [5] [6] [7]
(72,e)
(33,c)
(3,d)
(85,f)
(22,a)

20. Hash Table Issues The choice of hash function Overflow handling
The size (number of buckets) of hash table

21. Hash Functions Two parts
Convert key into an integer in case the key is not
Map an integer into a home bucket
f(k) is an integer in the range [0,b-1], where b is the number of buckets in the table

22. Converting String to Integer
Let us assume that each character is 2 bytes long
Let us assume that an integer is 4 bytes long
A 2 character string s may be converted into a unique 4 byte integer using the following code:
int answer = (int) s[0];
answer = (answer << 16) + (int) s[1];
In this case, strings that are longer than 2 characters do not have a unique integer representation
Read Example 10.8 and see Program 10.13

23. Mapping Into a Home Bucket
Most common method is by division
homeBucket = k % divisor
Divisor equals to the number of buckets b
0 <= homeBucket < divisor = b

24. Overflow Handling
Search the hash table in some systematic fashion for a bucket that is not full
Linear probing (linear open addressing)
Quadratic probing
Random probing
Eliminate overflows by permitting each bucket to keep a list of all pairs for which it is home bucket
Array linear list
Chain

25. Hashing with Linear Open Addressing
If a collision occurs, insert the entry into the next available bucket regarding the table as circular
Example
the size of hash table b = 11
f(k) = k % b
after inserting the three keys 80, 40, and 65

26. Linear Open Addressing
Example
after inserting the two keys 58 (collision) and 24
after inserting the key 35 (collision)

27. Linear Open Addressing
Search operation
The search begins at the home bucket f(k) of the key k
Continue the search by examining successive buckets in the table until one of the following happens:
(c1) A bucket containing an element with key k is reached
(c2) An empty bucket is reached
(c3) We return to the home bucket
In the cases of (c2) and (c3), the table contains no element with key k

28. Linear Open Addressing
Delete operation
Perform the search operation to find the bucket for key k
Clear the bucket
Then do either one of the following:
Move zero or more elements to fill the empty bucket
Introduce and use the NeverUsed field in each bucket (Read how this is done on page 388)
See Programs for hashTable class definition and operations

29. Performance of Linear Probing
The worst-case search/insert/delete time is (n), where n is the number of pairs in the table
When does the worst-case happen?
When all n key values have the same home bucket
For the worst case, the performance of hash table and linear list are the same
However, for average performance, hashing is much better
[0] [1] [2] [3] [4] [5] [6] [7]
(72,e)
(33,c)
(3,d)
(85,f)
(22,a)

30. Expected (Average) Performance
alpha = loading factor = n / b
Sn = average number of buckets examined in a successful search
Un = average number of buckets examined in an unsuccessful search
Time to insert and delete is governed by Un.
[0] [1] [2] [3] [4] [5] [6] [7]
(72,e)
(33,c)
(3,d)
(85,f)
(22,a)

31. Expected Performance Sn ~ ½ (1 + 1/(1-alpha)) Un ~ ½ (1+1/(1-alpha)2)
Note that 0 <= alpha <= 1.
alpha Sn
(buckets) Un
0.50
1.5
2.5
0.75
8.5
0.90
5.5
50.5

32. Hash Table Design
In practice, the choice of the devisor D (i.e., the number of buckets b) has a significant effect on the performance of hashing
Best results are obtained when D is either a prime number or has no prime factors less than 20
The key is how do we determine D (see the next slide)
Read Example 10.12

33. Methods for Determining D
First, determine what constitutes acceptable performance.
Use the formulas Un and Sn, determine the largest alpha that can be used.
From the value of n and the computed value of alpha, obtain the smallest permissible value for b.
Method 2:
Begin with the largest possible value for b as determined by the max. amount of space available.
Then find the largest D no larger than this largest value that is either a prime or has no factors smaller than 20.

34. Hashing with Chains Hash table can handle overflows using chaining
Each bucket keeps a chain of all pairs for which it is the home bucket (see Figure 10.3)
The chain may or may not be sorted by key
See Program for hashChains methods

35. Hash Table with Sorted Chains
Put in pairs whose keys are 6,12,34,29, 28,11,23,7,0, 33,30,45
Home bucket = key % 17.

36. Exercise & Reading Exercise Read Chapter 10
Suppose we are hashing integers with a 7-bucket hash table using the hash function f(k) = k % 7.
(a) Show the hash table if 1, 8, 23, 40, 51, 69, 70 are to be inserted. Use the linear open addressing method to resolve collisions.
(b) Repeat part (a) using chaining to resolve collisions. Assume the chain is sorted.
Read Chapter 10