Hashing

• Review: Hash Functions
• Review: Hash Tables

UUSet

• HashSet Structure
• T = type of elements in Set
• n = number of elements in set = size of Set
• H = hash function for T (may be for defined in terms of a key type K)
• B = Bucket type (a container holding elements of type type T)
• v = Vector of B<T> (aka "bucket vector")
• b = number of buckets = size of bucket vector
• HashSearch Algorithm: given t = search value of type T
1. Calculate hashValue = H(t)
2. Calculate index = hashValue % b
3. Search v[index] for t
4. Return result of search as (SizeType, B::Iterator)
• Set::Includes(t):
  
  1. (i,j) = HashSearch(t)
  2. if (j.Valid() && t == *j) t = *j
  3. (alternate) return SetIterator pointing to (i,j)
• Set::Insert(t):
1. (i,j) = HashSearch(t)
2. if (!j.Valid() || t != *j) v[i].Insert(j,t)
3. else *j = t;
• Set::Remove(t):
  
  1. (i,j) = HashSearch(t)
  2. v[i].Remove(j)

For each operation:
Expected (Average Case) Runtime	= Expected runtime of HashSearch(t)
	= Θ(average search time for bucket)
Assuming B = List and Sequential Search:
Expected Runtime	= Θ(average size of v[i])
	= Θ(size of set / number of buckets)
	= Θ(s/b)
Structural Foot Print	= Θ(s + b)
Runspace	= + Θ(1)
Assuming Θ(s) = Θ(b):
Expected Runtime	= Θ(1)
Foot Print	= Θ(s)
Runspace	= + Θ(1)

UUSet::Iterator

• Data
• Interface: Bidirectional Iterator
• Set::Begin()
• Iterator::++()
• Operations have amortized runtime = Θ(b/(s+1))