Status

• Exam 3 should be graded by Mon Wed. Solutions posted.
• CodingBat E01: extended by 2 days (til Friday morning).
• eCafe is open (course evals).
  • I'll remind you again closer to term end.
• William Albritton will be teaching ICS212 next term at LCC.
  • A couple options at UHM too.

What about getting bits out of a byte?

• Bit operators: >>, <<, >>>, ~, &, |, ^
• Numbers default to int data type, so work there when you can
• ints are always signed in Java (no unsigned ints; bit twiddling is easier in C)
• Masking
• Examples:

    byte[] data = {1, 2, 3, 4};
    int together = 0;
    for (byte b : data) {
      together = (together << 8) | b;
    }
    System.out.println(together); //0x01020304 = 16909060
  

    byte b = '3';  // or 51 or 0x33
    for (int i = 0; i < 8; i++) {  //prints: 00110011
      int mask = 0x0080 >> i;
      int bit = b & mask;
      bit = bit >> (7 - i);
      System.out.print(bit);
    }
    System.out.println();
  

  private int buffer = 0b11001100;   //or could be in a byte
  private int bits = 8;
  
  public int nextBit() {
      int bit = (buffer >> 7) & 1;  //grab left-most bit in buffer
      buffer <<= 1;                 //equivalent to: buffer = buffer << 1;
      bits--;                       //what to do when bits == 0?
      return bit;
  }
  

• This will be covered in more detail in lab.

ADT performance so far

• Stacks and Queues:
  • Add, remove, get in O(1), but only at ends
• Lists:
  • Add, remove, get in O(n) (or O(1) with iterator or get with array)
• BSTs
  • Add, remove, get in O(lg n) (heap: O(1) get)
• Can we do better? Say, O(1) to add, remove, and get (random access)?
  • Yes! Hash tables

Hash tables

• Array (or array-like data structure) + hash function
  • hash function: given an item, compute what cell (index) it goes into
• Similar concept to radix sort (and other distribution sorts)
• Example: Putting playing cards into a PlayingCard[52]
  • this is direct addressing (basically)

Hash function

• direct addressing doesn't scale
  • consider: UH student IDs
    • required array too big
    • lots of wasted space (empty cells)
  • non-integers: Strings, complex objects, etc.
• a function that maps the element (later: key) to array index
  • index in range of array
  • simplest: modulo
  • example: 10 UH students into an array of size 10

Collisions

• happens whenever not using direct addressing
• range of keys > array range
• Two (basic) ways to handle: open addressing or chaining

Open addressing: Linear probing

• Linear probing: On collision, put in next cell over... and over... (wrap around array)
• Try it:
  • Hash table: Array of size 7
  • Hash fn: abs(key) % 7 → index
  • Keys to add: 4, 8, -3, 24, 18, 13
• Full? Can track size separately or detect return to original hash index

Open addressing: Getting item back out

• Retrieve objects using hash value of original key value
• Given your hash, trace through:
  • Contains: 8, 24, 19
• Linear probing required again... hash to find start, but keep probing until hit an empty cell.

Open Addressing: Removal

• Since finding uses probing, deletion can mess things up...
• Find and remove: 24
• Now see if contains 18.
• Solution: Mark removed with special value (DEL, for example)
  • Probe over when seeking; can overwrite when adding.

Avoiding collisions: Load factor

• O(1) if no collisions, but up to O(n) if all mapped to one cell (bucket)
• Load factor
  • = (elements in table) / (size of table)
  • Around 0.7 is usually good
    • From textbook: 0.5 -> 1.5 probes; 0.75 -> 2.5; 0.9 -> 5.5
• Expand the table size
  • Need to rehash everything.
  • Consider: size from 7 to 14, element 8
  • Performance hit, though can spread this out over inserts by running both tables for a while
    • insert into new bigger one, but still lookup in old small one if not found there

Avoiding collisions: Hash fn

• Good hash function = hard to do!
• Hash fn: = 1     No. Very bad.
• Hash fn: (int) (Math.random() * array.length)
  • NO! Hash must be deterministic
  • Two equal objects must always hash to same bucket (will revisit this with .equals method)
• Put these into an array of size 10: 93, 43, 73, 63, ...
  • Basically powers of 10 ignore initial digits
  • Powers of 2 have this same effect on binary
  • Thus, prime number array length usually works well
• Strings: sum characters values and then %
  • But consider: snail, slain, nails.
  • A more complicated hash fn includes position
  • (BTW: Can also hash entire files like this, such as for cryptography or file ID/fingerprinting)
• What if our values were all 1 to 10, % 7?
  • Should map to all cells with equal likelihood

Avoiding collisions: Avoiding clusters

• Quadratic probing
  • instead of linear +x (where x = 1, 2, 3, 4), +x^2
  • still get clumps, but spreads out a bit
• Double hashing
  • secondary hash fn (and then probing)

Chaining

• Alternative to open addressing
• Generally simpler and more common
• buckets: Each cell is head of a linked list (stack)
  • Add: hash to bucket, add at head of list
  • Find: hash to bucket, loop through list there
  • Remove: hash to bucket, loop through to element, and remove
• Related concept: Bucket sort

Chaining: Try it

• Hash table: Array of size 7
• Hash fn: abs(key) % 7 → index
• Keys to add: 4, 8, -3, 24, 18, 13
• Contains: 8, 4, 19, 17
• Remove: 18, -3

Chaining Limitations

• Load factor still a factor
  • no neighbors -> clusters to compound the problem though
  • still want to expand table to keep lists short
    • if lists under a constant limit, O(1) performance
• Still need a good hash fn to spead over all buckets
• Hash fn, while constant, is not 0-time
  • complex objects with lots of fields

Iteration

• List all element in hash
• In open addressing vs chaining
• Get a "random" order
  • Fairly easy/low cost to maintain DL-list to maintain order by insertion, though

Summary

• Hash tables: Array + a hash fn to determine which bucket an element goes into
• Direct addressing (or other perfect hashing): no collisions
• In real world:
  • avoid collisions as much as possible
    • Good hash function to spread things out (hard to do well)
  • manage collisions when they do happen
    • Open-addressing (with linear probing, or other fall-backs)
    • Chaining (simpler)
• Keep load factor down to get required performance
  • Considered to be O(1) given these constraints
  • If done very badly, O(n)

Job Interview Question #1

Given an int array A and an int value X, 
 print all index pairs (i,j) such that A[i] + A[j] == X.

• Once you've found a solution:

  Is your solution optimal (ie, most efficient in terms of worst-case big-O)?  
  Prove it.
  

• One solution:

    for (int i = 0; i < a.length; i++) {
      for (int j = 0; j < a.length; j++) {
        if (a[i] + a[j] == x) {
          System.out.print("(" + i + "," + j + ") ");
        }
      }
    }
  

• Big-O: O(n^2). Can't we do better? One possible proof:

  Proof by contradiction: Suppose A contains all 1s and X == 2.
  Even if we could somehow magically find all solution pairs in faster time,
  simply printing those solutions would require printing all possible (i,j) pairs.
  So, in this worst-case scenario, O(n^2) is the best we can do.
  

• Now, on average case, we could do better (if # of matching js for each i is small):
  • X - A[i] == A[j]. So, we could:
    • dump (value, index) objects into an array, sort by value, then use binary search to grab matching pairs = O(n lg n) for sort + n * O(lg n) to find matching j for each i.
    • use map/hashing [haven't covered this in 211 yet] to cut out both the sort and search times = O(n) to hash all + O(n) to find all matching pairs.

Job Interview Question #2

Given a string, titlecase all of the words in that string.
(Titlecase = intialial capital letter and the rest lowercase.)

For next time...

• A10 (start now! 80 points, lots of sequential steps, all-or-nothing outcome)
• Quiz 12 to be posted
• Will record EC on Friday (or as soon as we get to it after that...)
• Next time: Maps and Sets (ADTs that rely on hash tables)