CS 221 Guest lecture: Cuckoo Hashing Shannon Larson March 11, 2011

Learning Goals Describe the cuckoo hashing principle Analyze the space and time complexity of cuckoo hashing Apply the insert and lookup algorithms in a cuckoo hash table Construct the graph for a cuckoo table

Remember Graphs?

Graph Cycles A graph cycle is a path of edges such that the first and last vertices are the same

Recall Hashing

Cuckoo Hashing: the idea

Why is this cool? Perfect hashing guarantees – O(1) lookup, O(1) insert Cuckoo hashing guarantees – O(1) lookup – O(1) insert** Other hashing strategies can’t guarantee this! Also, it’s an option for your final project ** There’s a caveat here, but we’ll see it later

Cuckoo Hashing: Two Nests

Cuckoo Hashing: Example x

y x

z x y oh no!

Cuckoo Hashing : Example z x y NOW we’re fine!

Cuckoo Hashing : Example x y z

Why two tables? Two tables, one for each hash function Simple to visualize, simple to implement But, why two? One table works just as well! Just as simple to implement (all one table)

One Table Example x

y x

z x y oh no!

One Table Example z x y

x y z

x y z

Graph Representation How can we represent our table? Why not a graph? – Nodes are every possible table entry – Edges are inserted entries This is a directed graph Direction from current location TO alternate location

Graph Example Remember our one-table example? x y z

Infinite Insert Suppose we insert something, and we end up in an infinite loop – Or, “too many” displacements – Some pre-defined maximum based on table size

Example: Loops Remember our one-table example? x y z

Example: Loops x y z w

x y z a w

a y x z w

a y x w z

Notice what happens to the graph We keep going and going and going…

Analysis: Loops

What can we do once we get a loop? – Rebuild, same size (ok solution) – Double table size (better solution) We’ll need new hash functions for both

Analysis Lookup has O(1) time – At MOST two places to look, ever – One location per hash function Insert has amortized O(1) time – Think of this as “in the long run” – In practice we see O(1) time insert – You’ll see amortized analysis in CPSC 320 Remember the “grass and trees” analysis?

Lookup: The Code

Insert: The Code

Analysis: Load Factor

More hash functions What would this look like? We would have three tables (simple case) – One hash function per table Or, we would have two alternates (one table)

More hash functions x y z

Even better load? Currently we’ve only put one item per bucket What if we had two cells per bucket? x,w y,a z

Even better load? Currently we’ve only put one item per bucket What if we had two cells per bucket? What about collision strategies? – Round-robin (cells take turns swapping out) – FIFO (oldest resident gets kicked out)

Even better load?

Links & Resources undergrad.pdf undergrad.pdf No neat animations on the internet…yet! – Possible personal project? – Brownie points? – Pre-coop project?