Hash

The goal

To illustrate linked structures using the hash table and to show how use use classes of the Java Collections Framework in the implementation of a hashes.

Etymology

• the key on the telephone
• hash vs pound vs sharp
• Twitter #hashtag

Our use of hash is more related to the dish, the hash chops us information.

A little explanation

• The Node Class
• The linked list
• Adding the first element
  • the “dummy” node
• Adding other elements
• Stack as a linked list
• Stack as an array
• Hash tables

Also, try the YouTube video.

Ways of using the array

• closed hashing or open addressing — values stored in array
• open hashing with chaining — values stored in lists accessed from arrays

A driving reader

package edu.unca.cs.csci202;

import java.util.Scanner ;

public class HashIt {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in) ;
        while (stdin.hasNext()) {
            String line = stdin.nextLine() ;
            try {
                Scanner lineIn = new Scanner(line) ;
                String firstWord = lineIn.next() ;
                if (firstWord.equals("?")) {
                    String key = lineIn.next() ;
                    System.out.println("Looking for " + key) ;
                    System.out.println("Hash of "+key+" is "+key.hashCode()) ;
                } else {
                    String key = firstWord ;
                    long value = lineIn.nextLong() ;
                    System.out.println("Associating "+key+" with "+value) ;
                    System.out.println("Hash of "+key+" is "+key.hashCode()) ;
                }
            } catch(Exception e) {
                System.err.println("Something bad with " + line) ;
                return ;
            }
        }
    }
}

Closed hashing

Creating the arrays

Choose an array size and a hash function.

    static private final int HASHSIZE = 2013 ;

    private static int getSlot(String key) {
        int hashIndex = (key.hashCode()&0x7FFFFFFF)%HASHSIZE ;
        return hashIndex ;
    }

Handling collisions

If a slot is full, just go to the next free one. Be sure to wraparound at the end of the array.

    private static int getSlot(String key) {
        int hashIndex = (key.hashCode()&0x7FFFFFFF)%HASHSIZE ;
        while (keys[hashIndex] != null && !key.equals(keys[hashIndex]) {
            if (++hashIndex == HASHSIZE) {
                hashIndex = 0 ;
            }
        }
        return hashIndex ;
    }

Plus and minus

Closed hashing works well it there are plenty of open slots. If there are twice as many slots as needed, the average number of probes will be two.

It is also possible to create larger arrays that are populated with the present values.

Open hashing with chaining

You’ll need a data structure to represent the nodes.

package edu.unca.cs.csci202 ;

class StringLongNode {
   
    public String key ;
    public long value ;
    public StringLongNode next ;

    public StringLongNode() {
        this(null, 0L, null) ;
    }

    public StringLongNode(String key, long value) {
        this(key, value, null) ;
    }
    
    public StringLongNode(String key, long value, StringLongNode next) {
        this.key = key ;
        this.value = value ;
        this.next = next ;
    }
}

Unordered list

For unordered list, you need a method with the following header.

    private static StringLongNode lookupKeyInChain(String key, int slot) ;

You will call lookupKeyInChain with a statement similar to the following.

    StringLongNode matchNode = lookupKeyInChain(key,slotNum);

Ordered lists and dummy nodes

Sometimes programmers keep the elements of the linked list sorted and use dummy nodes to simplify the programming of the lists. Sorting the lists gives a rather small performance improvement, especially when comparing to just doubling the size of the arrays; however, it is a good exercise in improving programming skills.

Also, it makes a little more sense in C++ than it does in Java.

Dummy nodes

We are going to use StringLongNode objects with a null key to be dummy nodes. You can use any value you desire.

A modified lookup method

We want to make a add a new method called lookupKey with the following methods header.

    private static StringLongNode lookupKey(String key) ;

The first action of lookupKey will be to use the hash function to find the chain. From now on, assume that the keys in the chain are sorted. Otherwise, this description will make little sense.

If the search key is in the chain, continue to return the StringLongNode containing the search key. If the chain contains only a dummy node or if the search key is less than any key in the chain, return the dummy node. Otherwise, return the last StringLongNode with a key less than the search key.

Use the compareTo method of String to compare keys.

Note the lookupKey should never return null. However, it may return the dummy node.

Look at this code very carefully. It should be no more than six lines long.

If the key lookup case is working, it’s time to try out the key update case.

The standard stack operations

• create
• push — add a new element
• pop — remove and return most recent element from the stack