Lecture 20: More Hashing

Overview

  1. Review of Last Time
  2. Subtleties and the Art of Hashing
  3. Implementations

Last Time

Hash tables with chaining!

  • Goal: implement unordered set ADT–find, add, remove

  • Assumption: given a hash function $h$

    • $h$ takes an object instance as its argument
    • $h$ returns a hash code associated with instance from a specified range

Hash Table with Chaining

Have array arr of lists, element x is stored in list arr[h(x)]

Example

  • red -> 2
  • orange -> 0
  • yellow -> 4
  • green -> 1
  • blue -> 0
  • indigo -> 2
  • violet -> 0

Also Last Time

Performance of operations depends on occupancy (size) of lists

  • occupancy determined by hash values of elements
  • a good hash function should “spread out” values among possible inputs

The Art of Hashing

Choose a hash function $h$ whose output “looks random”

  • distinct values $x, y$ are “unlikely” to have $h(x) = h(y)$

Hash function value determined by data stored in instance so not really random

Hashing Strings in Java

String s stores an array of chars

  • each char has associated ASCII value
  • interpret a char as a value from 0 to 255

Let n = s.length, interpret s as char array

Java computes

s.hashCode() = s[0]*31^(n-1) + s[1]*31^(n-1) + ... + s[n-2]*31 + s[n-1]

where result is computed as an int

Example

String s = "bake"

As a character array:

s = ['b', 'a', 'k', 'e']

  = [98,   97, 107, 101]

Computing hash code:

int h = 98 * 31^3 + 97 * 31^2 + 107 * 31 + 101

      = 3016153

You can confirm this with s.hashCode() in Java!

Question

s.hashCode() returns an int

  • value could be anything in the int range!

How could we get a value from a prescribed range?

  • e.g., want a value from 0 to n-1

Suggestion

If we want a value from 0 to n-1, use

  • s.hashCode() % n

Is this good?

Challenge

Using

  • s.hashCode() = s[0]*31^(n-1) + s[1]*31^(n-1) + ... + s[n-2]*31 + s[n-1]
  • i = s.hashCode() % n

find a value of n and many strings s that hash to same value of i

Bad Behavior

Conclusion

Need to be careful with constructing hash functions!

Balance requirements:

  • random looking
    • minimize likelihood of “hidden” patterns
  • consistency
  • efficiency

Hashing in Java

Object class has a method int hashCode()!

hashCode() requirements from Java API:

  • if we have Object x and invoke x.hashCode() multiple times in the same execution, all calls must return the same value
    • different values may result from different executions
  • if x.equals(y), then we must have x.hashCode() == y.hashCode()
  • not required that x.equals(y) == false implies x.hashCode() != y.hashCode)

As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects.

Your Responsibility

When defining a new class, define a hashCode() method with properties specified in Java API

Remaining Challenge

The hashCode() method returns an arbitrary int value

  • assume x.hashCode() == y.hashCode() is “unlikely” unless x.equals(y)

For hash tables, we need a hash value in a specified range 0, 1,...,n-1!

  • cannot do anything about collisions x.hashCode() == y.hashCode()
  • want to ensure that if x.hashCode() != y.hashCode() then index of x is “unlikely” to equal index of y

Implementation: define method int getIndex(E x)

  • method uses x.hashCode()
  • returns a value in range 0, 1,..., arr.length - 1

What Might Be Problematic?

int capacity; // size of array

int getIndex(E x) {
    return x.hashCode() % capacity;
}

Better Hashing

Goal. Given an arbitrary int h = x.hashCode(), compute an index i from h such that:

  1. i is in range 0, 1,...,n-1
  2. if h != k, then associated indices i and j are unlikely to be same
    • how unlikely?

Binary

In Java, ints are 32-bit values

  • 0 = 00000000000000000000000000000000
  • 1 = 00000000000000000000000000000001
  • 2 = 00000000000000000000000000000010
  • 3 = 00000000000000000000000000000011
  • 4 = 00000000000000000000000000000100
  • 5 = 00000000000000000000000000000101
  • …

Last (right-most) bit is least siginificant bit

First is “sign” bit

Operations

Operations in binary are like grade-school arithmetic, but with only 1s and 0s:

    00000000000000000000000000000011
	
 +  00000000000000000000000000000110
  
  =

    00000000000000000000000000000011

  * 00000000000000000000000000000110
  
  =

Observation (Vague)

If we start with a non-zero number h and multiply it by a random odd number r and multiply h and r, the higher order bits of h * r tend to be random-ish

    00000000000000000000100010110000   (h)

  * 10111000110110000111000111010101   (r)
  
  = ???????????????????????????10000

Get Index Method

  1. Choose an odd random number r
    • fixed at beginning of execution (when we initialize hash table)
  2. Maintain that array capacity is always a power of 2
    • n = 2^k for some value of k
    • indices encoded with k bits
  3. To generate index i from hash code h, take i to be the k most significant bits of h * r 
    00000000000000000000100010110000   (h)

  * 10111000110110000111000111010101   (r)
  
  = ???????????????????????????10000

Implementation in Java

    protected int getIndex(E x) {
	// r is a fixed odd number that was randomly 
	// chosen when table was constructed
	// k is the log of the capacity (i.e., capacity = 2^k)
	
	//get the first logCapacity bits of z * x.hashCode()
	return ((r * x.hashCode()) >>> (32 - k));
    }

The operator >>> is the unsigned bit shift operator

Guarantee

    protected int getIndex(E x) {
	// r is a fixed odd number that was randomly 
	// chosen when table was constructed
	// k is the log of the capacity (i.e., capacity = 2^k)
	
	//get the first logCapacity bits of z * x.hashCode()
	return ((r * x.hashCode()) >>> (32 - k));
    }

Assume

  • r is a randomly chosen odd number
  • x and y are objects with different hash codes
  • n = 2^k is the size of arr

Then the probability (over choice of r) that getIndex(x) == getIndex(y) is at most 1/n

Informally: collisions are as unlikely as possible!

Wild Idea

To get from x.hashCode() to index from 0,1,...,n-1 with n = 2^k

  • pick a random function from 32 bt ints to k-bit values
    • randomness from choice of r
  • use the same function (value of r) for every call to getIndex

A Miracle:

  • This method makes collisions unlikely, not matter what (distinct) hashCode() values are given!

Next Assignments

Assignment 08.

  • Complete an implementation of a hash table for SimpleUSet
  • Use implementation to implement a “hash map”

Assignment 09. (Optional)

  • Explore statistical properties of random assignments
  • “Balls in bins”