Closed Hashing

• A second method for resolving collisions.
• No linked lists are used.
• The Hash table must be at least size n, the number of items to insert.
• Linear Probing
  • If there is a collision, just move to the next element in the array.

  • LINEAR_PROBE_FIND(H,k)
    
     pos ← h(k)
     if (H[pos] = NULL then
        return NOT_FOUND
     elseif H[pos].key = k
        return pos 
     else
          i ← (pos+ 1) % m
          while pos != i do
             if H[i] = NULL then
                   return NOT_FOUND
             elseif  H[i].key = k then
                   return i 
             i ← (pos+ 1) % m
     return NOT_FOUND
    
    	 

  • In this scheme deletion becomes a problem
    • Assume a and collide
    • Inserting a fills the slot
    • Inserting b fills the slot after a
    • Deleting a frees a's slot
    • Searching for b yields an empty slot where a was, so the assumption is that b was not in the table.
  • A special "deleted" marker can be used to overcome this
    • But there is a wasted space then.
  • It also increases the chance of collisions for "clustered" hash keys.
  • Assume a and b collide and h(c) = h(a)+1
  • As the table fills, search times increase greatly.
• Quadratic Hashing
  • h(k,i) = h'(k_ + c₁i + c₂i²) % m
  • For i = 0,1,2,....
  • if c₁ = c₂ = 1, the search is h'(k), h'(k)+2, h'(k)+6
  • For m=2ⁿ c₁ = c₂ = 1/2 are good choices.
  • h(k,i) → h'(k), h'(k)+1, h'(k)+3, h'(k)+6
  • Choices of c₁ and c₂ are critical as the function may loop without place an item in a not-full table.
  • Furthermore if h'(a) = h'(b), we have the same problem as linear probing since h(a,i) = h(b,i) for all i.
• Double Hashing
  • h(k,i) = (h₁(k) + i*h₂(k)) % m
  • Since the key is used in two different hash functions, unless they are poorly chosen, the probability of two keys hashing to the same value multiple times are greatly reduced.
  • Again, the functions must be carefully chosen.
  • For prime m, your author suggests m-2-k % (m-2), 8-(k % 8), and k % 91 + 1 for h₂
  • CLRS suggests let m be a power of 2 and h₂ always produces an odd number.
  • CLRS suggests that other probing sequences have Θ(m) sequences
  • But that Double hashing has Θ(m²) sequences.