Hashing


There are times when you need to retrieve values from a table instantaniously.  The tables studied so far do not permit this.

A hash table maps a specific key directly to the value stored.  Thus, by passing the key we can retrieve the value in one step.

A hash table is similar to an array.  With an array, you have an index number mapped to a value.  With a hash table, you use the search key to calculate the index position in which to place it.  You calculate the index position using what's called a hash function. The index position returned from a hash function is called a hash key.


Definitions:

	search key:	the unique value identifying the record
	
	hash key:	the index position in which to store the record

The requirements for a hash function are:

	1.  Fast and easy to compute
	2.  Places items evenly throughout the table
	3.  The key must not be larger than the table size


Some common hash functions for numeric search key

	Selecting digits
	
		Choose specific digits from the number to form the hash key
		
			If the value is a SSN, you could choose the 4th and 9th digits
			
				h(001364825) = 35
				
				The record would be stored in T[35]
				
	Folding
	
		Simply add the digits together to generate the hash key
		
			h(001364825) = 0 + 0 + 1 + 3 + 6 + 4 + 8 + 2 + 5 = 29
			
			The record would be stored in T[29]
			
			With this hash function, the maximum size of the hash table would be 81
			
			h(999999999) = 9 + 9 + 9 + 9 + 9 + 9 + 9 + 9 + 9 = 81
			
		Another option is to group the digits in the search key
		
			h(001364825) = 001 + 364 + 825 = 1190
			
			With this hash function, the maximum size of the hash table would be 2997
			
			h(999999999) = 999 + 999 + 999 = 2997
			
	Modulo Arithmetic
	
		The simplest and most effective hash function.  Take the remainder after dividing by the table size:
		
			h(x) = x mod TableSize
			
		This works most effectively when the table size is a prime number.  We'll look at this in more detail later.
		
	It is acceptable to use more than one hash function at a time.

		1.  Hash the search key to return a hash key.
		2.  Hash the hash key from step one using a different hash function

Converting strings to numbers
	
	There are times when the search key is a string instead of a number.  It will be necessary to convert the string to a number before applying the hash function.  A few common methods:


		Convert the letters to ASCII values

			h("NOTE") = 78 + 79 + 84 + 69 = 311

		Convert the letters to their position in the alphabet

			h("NOTE") = 14 + 15 + 20 + 5 = 54

	The problem with the two methods above is that other search keys may convert to the same value:

		h("TONE") = 20 + 15 + 14 + 5 = 54


	One solution would be to convert the numbers to 5-bit binary numbers, concatenate, then convert to base 10
	
		h("NOTE")	= 14 + 15 + 20 + 5
					= "01110" + "01111" + "10100" + "00101"
					= 01110011111010000101
					= 474757
		
	Why a 5-bit binary number? I chose the position in the alphabet for the number.  The largest number would be 26. Converted to binary this would be 11010, a 5-bit binary number.
	
	The steps involved would be as follows:
	
		1. Convert letter to numeric equivilant
		2. Convert numbers to 5-bit binary
		3. Concatenate the binary numbers
		4. Convert the new binary number to base 10
		
	Let's develop a simpler process for this computation.
	
	The first step is recognizing that the numeric representations of the letters, through the process of converting to 5-bit binary numbers, is essentially the same as treating it as a base 32 number ( 2^5 = 32):
	
		14-15-20-5 base 32
		
	To convert a base 32 to base 10:
	
		14 * 32^3 + 15 * 32^2 + 20 * 32^1 +  5 * 32^0
		
	Notice the pattern of the exponent- it starts at 0 on the far right side, and increases by one for each position.  We could easily develop an alogorithm to handle this:
		
		long hashKey(string searchKey) {
		
			int len = searchKey.length();
			long lRetVal = 0;
			
			for ( int i=0; i<len-1; i++ ) {
				// Assume searchKey is passed in as all caps
				// Convert to ASCII and subtract 64 to gets its positional value
				lRetVal += (searchKey[i] - 64) * 32;
			}
			lRetVal += (searchKey[i] - 64);
			return lRetVal;
		}


	Alternatively, we could factor the above formula to give us:
	
		(( 14 * 32 + 15 ) * 32 + 20 ) * 32 ) + 5
		
	This is known as Horner's rule, or Horner's method.  Again, notice the pattern:
	
		1. Start with the first number
		2. Multiply by 32 and add the next number
		3. Repeat step 2 until there are no more numbers
		
	We could easily develop a recursive alogorithm to handle this:
	
		long hashKey(string searchKey) {
			int len = searchKey.length();
			long lRetVal = searchKey[0] - 64;
			if ( len == 1) then return lRetVal;
			else return lRetVal * 32 + hashKey(searchKey.substr(1));
		}


Ideally, you would like a hash function that maps each key to a unique location in the table.  However, it will often happen that two or more values will generate the same key.  This is known as a collision.  There are several methods for resolving these collisions.

There are two approaches to resolving collisions:


	Open Addressing
	
		Open addressing allows for only one item per table position.  If a position in the hash table is already occupied, then you probe for the next open spot.
		
		Linear Probing
		
			Advance one position at a time until an open position is found.
		
				Step 1: If position 5 is taken, look at position 6 (5 + 1).
				Step 2: If position 6 is taken, look at position 7 (5 + 2).
				
				Continue until an empty position is found.
			
			The size of each jump is 1.  The draw-back to this process is that if several search keys hash to the same position, the the values tend to cluster together.  This called primary clustering.
			
		Quadratic Probing
		
			You can minimize primary clustering by using quadratic probing.  Instead of advancing one position at a time, you advance by the square of the step number.
			
				Step 1: If position 5 is taken, look at position 6 (5 + 1^2).
				Step 2: If position 6 is taken, look at position 9 (5 + 2^2).
				
				Continue until an empty position is found.
				
			The size of each jump is the square of the step number.  Eventually, you will have several search keys that hash to the same position.  This clustering effect is called secondary clustering.
			
			
		Double Hashing
	
			The two methods above are key independent.  What that means is the the formula used to determine the next position to look at has nothing to do with the search key itself.
			
			To keep clustering to an absolute minimum, use one hash function on the search key to determine the initial position, then use a second hash function on the search key to determine the size of the jump.
			
			To guidelines to be aware of:
			
				1.  The second hash key cannot be 0, as this value determines the step size.
				
				2.  The second hash key cannot equal the first to avoid clustering.
				
			Let's visit again the modulo hash function and the table size equal to a prime number.  If the size of the table and the size of the probe step are relatively prime, then the double hash process will allow you to visit every open position in the table.
			
				Example- if the table size is 7, the probe step size is 3, and you start at position 0, you will visit the positions in the table in the following order:
				
					0: start position
					3: ( 0 + 3 ) mod 7
					6: ( 3 + 3 ) mod 7
					2: ( 6 + 3 ) mod 7
					5: ( 2 + 3 ) mod 7
					1: ( 5 + 3 ) mod 7
					4: ( 1 + 3 ) mod 7
					0: ( 4 + 3 ) mod 7
					
				Notice that we visited every position before returning to the start position.
				
		Increase the Size of the Table
		
			As the hash table fills, the probability of collision increases.  Hash tables work best when only partially filled, since you cannot guarantee unique hash keys for every search key.
			
			A few rules for increasing the size of the array:
			
				1. Make sure the new size is still a prime number.
				
				2. Do not simply copy the items into the new table if you are using a modulo hash function, because the position of the item depends on the table size.  Each item must be re-hashed to its proper position in the new table.
				
	Restructuring the Table
	
		In open addressing, only one item is permitted per position.  You could alter the table to allow multiple items per position.
		
			Buckets
			
				A bucket is simply an array at each position in the table.  Essentially, the table is a two dimensional array.  The problem is, eventually the sub-array will be filled, and you will have to either resize it or resort to a probing scheme.
				
			Separate Chaining
			
				Each position in the array is a pointer to a linked list.  Therefore, the size of each is dynamic.
				
		The drawback to both of these methods is that, once you've located the correct position, you then have to search the array or list (probably with a binary search) in order to finally find the correct item.