ICS 22 Klefstad Week 7 Hashing and Hash Tables

Tables

an indexed container
associate information with a key
- key is often a character string
- info is any information
EG a phone book
- key is the name of a person or business
- info is their address & phone number

Typical Operations on Tables

void insert(String key, Object o);
Object lookup(String key);
void remove(String key);

Alternative implementations include
- Search Lists
- Hash Tables
- Binary Search Trees

Hash Tables

O(1) on average for insert, lookup, and remove
use an array named T of size T.length
define a hash function that returns an integer
```
int hash(String key)
```
store the key and info at
```
T[hash(key)]
```
hash(key) must always return the same integer for a given key
hash(key) must return an integer between 0 and T.length-1

Hash Functions

a good hash function has the following characteristics
- avoids collisions
- spreads keys evenly in the array
- inexpensive to compute - must be O(1)
Table size is usually prime to avoid bias
overly large table size means wasted space
overly small table size means more collisions
what happens as table size approaches 1?

Hash Function for Signed Integer Keys

remainder after division by table length

if keys are positive, you can eliminate the abs

int hash(int key, int N)
{
  return Math.abs(key) % N;
}

Hash Functions for Strings

must be careful to cover range from 0 through T.length-1
letters and digits fall in range 0101 and 0172 octal
so all useful values are in lowest 6 bits

s.length() has a constant limit, so hash(s,T.length) is O(1)

static final int shift = 6;
static final int mask = ~0 >> (32-shift); // only lower 6 bits on
int r = 0;
for (int i=0; i<value.length(); i++)
  r = (r << shift) | (value.charAt(i) & mask);
return Math.abs(r) % N;

Implementation

A hash table with separate chaining

class ChainedHashTable
{
  int hash(String value, int N) // as given above
  static class ListNode
  {
    String key;
    Object info;
    ListNode next;
    ListNode(String k, Object ob, ListNode n)
    {
      key = k; info = ob; next = n;
    }
    static ListNode find(String k, ListNode l);
    static ListNode remove(String k, ListNode l);
  }
  ListNode [] T;
  ChainedHashTable(int numberOfSlots);
  void insert(String key, Object info);
  Object lookup(String key);
  void remove(String key);
  String toString();
}