Double Hashing in Java

In programming, while we deal with data structure sometimes, we required to store two objects having the same hash value. Storing two objects having the same hash value is not possible. To overcome this problem, data structure provides collision resolution technique. In this section, we will focus only on double hashing, its advantages, example, and formula.

Data structure provides the following collision resolution techniques:

Separate Chaining (also known as Open Hashing)
Open Addressing (also known as Closed Hashing)

Linear Probing
Quadratic Probing
Double Hashing

What is double hashing?

It is a collision resolution technique in open addressing hash table that is used to avoid collisions. A collision occurs when two keys are hashed to the same index in a hash table. The reason for occurring collision is that every slot in hash table is supposed to store a single element.

Generally, hashing technique consists a hash function that takes a key and produces hash table index for that key. The double hashing technique uses two hash functions so it is called double hashing. The second hash function provides an offset value if the first hash function produces a collision. In other words, we can say that when two different objects have the same hash, is called collision.

Hash Function

A hash function is a function that accepts a group of characters (key) and maps that key to a value of a certain length (called a hash value or hash). The process is called hashing. It is done for indexing and locating items in databases. It provides an easy way to find longer value associated with the shorter hash value. It is widely used in encryption. It is also known as a hashing algorithm or message digest function.

Double Hash Function

The first hash function determines the initial location to located the key and the second hash function is to determine the size of the jumps in the probe sequence. The following function is an example of double hashing:

In the above function, the value of i will keep incrementing until an empty slot is found.

If the table size is prime, the double hashing works well.

Where PRIME is a prime smaller than tableSize.

If the above functions compute an offset value that is already occupied by other object, it means there is a collision. A good hash function must have the following properties:

Quick to evaluate.
Differ from the original hash function.
Never evaluates to 0.

Advantages of Double Hashing

The technique does not yield any clusters.
It is the best form of probing because it can find next free slot in hash table more quickly than linear probing.
It produces a uniform distribution of records throughout a hash table.

Double Hashing Example

Suppose, we have a hash table of size 11. We want to insert keys 20, 34, 45, 70, 56 in the hash table. Let's insert the keys into hash table using the following double hash functions:

h₁(k) = k mod 11 (first hash function)

h₂(k) = 8 - (k mod 8) (second hash function)

first, we will create a hash table of size 11.

Let's insert key one by one.

Steps	Key	Hash Function	Index	Description
1	20	h₁(20) = 20 mod 11	9	No collision occurs.
2	34	h₁(34) = 34 mod 11	1	No collision occurs.
3	45	h₁(45) = 45 mod 11	1	Collision occur because index 1 is already occupied by 34. Now we will use the second hash function to calculate the index for the key 45.
3	45	h₂(45) = 8 - (45 mod 8) = 3 h(45, 1) = (1 + 1 * 3) mod 11	4	Here, we have taken the value if i 1 because first collision occurs. Note that here h₂ (k) and 11 are relatively prime. The value of h₂ (k) must be less than the table size.
4	70	h₁(70) = 70 mod 11	4	Collision occur because index 4 is already occupied by 45. Now we will use the second hash function to calculate the index for the key 70.
4	70	h₂(70) = 8 - (70 mod 8) = 2 h(70, 1) = (4 + 1 * 2) mod 11	6	Here, we have taken the value if i 1 because first collision occurs. Note that here h₂ (k) and 11 are relatively prime. The value of h₂ (k) must be less than the table size.
5	56	h₁(56) = 56 mod 11	1	Collision occur because index 1 is already occupied by 34. Now we will use the second hash function to calculate the index for the key 56.
		h₂(56) = 8 - (56 mod 8) = 8 h(56, 1) = (1 + 1 * 8) mod 11	9	Again, collision occur. The index 9 is already occupied by 20.
		h(56, 2) = (1 + 2 * 8) mod 11	6	Here, the value of i is incremented by 1 because collision occurs second times. We note that again collision occurs because the index 6 is already occupied by 70.
		h(56, 3) = (1 + 3 * 8) mod 11	3	Here, the value of i is incremented by 1. The third index is empty. So, we will store 56 at index 3.

*indexes that are bold denotes collision.

After inserting all the keys, the hash table looks like the following.

Now we have clearly understood the double hashing. So, we can easily differentiate linear and quadratic probing.

In the linear probing, if collision occurs at any index, we look for the immediate next index. If the next index is also occupied, we look for the immediate next index. The process repeats until we get an empty index.

In quadratic probing, if collision occurs at any index, we look for the immediate next index. If the next index is also occupied, then we jump to the i² index.

Suppose, index 2 is already occupied, then we look for 2² i.e. 4. It means look 4 indexes ahead from the current index (i.e. 2).

Similarly, if index 3 is also occupied, then we look for 3² i.e. 9. It means look 9 indexes ahead from the current index (i.e. 3).

Double Hashing Algorithm for Inserting an Element

Set index = H(K); offset = H2(K)
If table location index already contains the key, no need to insert it. Done!
Else if table location index is empty, insert key there. Done!
Else collision. Set index = (index + offset) mod M.
If index == H(K), table is full! (Throw an exception, or enlarge table.) Else go to step 2.

Let's implement the above algorithm in a Java program.

Double Hashing Java Program

In the following Java programs, we have implemented double hashing in hash table.

DoubleHashingExample.java

import java.util.Scanner;
import java.math.*;
/* Class LinkedHashEntry */
class HashEntry
{
    String key;
    int value;

   /* Constructor */
    HashEntry(String key, int value)
    {
        this.key = key;
        this.value = value;
    }
}

/* Class HashTable */
class HashTable
{
    private int TABLE_SIZE;
    private int size;
    private HashEntry[] table;
    private int primeSize;

   /* Constructor */
    public HashTable(int ts)
    {
        size = 0;
        TABLE_SIZE = ts;
        table = new HashEntry[TABLE_SIZE];
        for (int i = 0; i < TABLE_SIZE; i++)
            table[i] = null;
        primeSize = getPrime();
    }
   /* Function to get prime number less than table size for myhash2 function */
    public int getPrime()
    {
        for (int i = TABLE_SIZE - 1; i >= 1; i--)
            {
                int fact = 0;
                for (int j = 2; j <= (int) Math.sqrt(i); j++)
                    if (i % j == 0)
                        fact++;
                if (fact == 0)
                    return i;
            }
       /* Return a prime number */
        return 3;
    }
   /* Function to get number of key-value pairs */
    public int getSize()
    {
        return size;
    }
    public boolean isEmpty()
    {
        return size == 0;
    }
   /* Function to clear hash table */
    public void makeEmpty()
    {
        size = 0;
        for (int i = 0; i < TABLE_SIZE; i++)
            table[i] = null;
    }
   /* Function to get value of a key */
    public int get(String key)
    {
        int hash1 = myhash1( key );
        int hash2 = myhash2( key );
        while (table[hash1] != null && !table[hash1].key.equals(key))
            {
                hash1 += hash2;
                hash1 %= TABLE_SIZE;
            }
        return table[hash1].value;
    }
   /* Function to insert a key value pair */
    public void insert(String key, int value)
    {
        if (size == TABLE_SIZE)
            {
                System.out.println("Table full");
                return;
            }
        int hash1 = myhash1( key );
        int hash2 = myhash2( key );
        while (table[hash1] != null)
            {
                hash1 += hash2;
                hash1 %= TABLE_SIZE;
            }
        table[hash1] = new HashEntry(key, value);
        size++;
    }
   /* Function to remove a key */
    public void remove(String key)
    {
        int hash1 = myhash1( key );
        int hash2 = myhash2( key );
        while (table[hash1] != null && !table[hash1].key.equals(key))
            {
                hash1 += hash2;
                hash1 %= TABLE_SIZE;
            }
        table[hash1] = null;
        size--;
    }
   /* Function myhash which gives a hash value for a given string */
    private int myhash1(String x )
    {
        int hashVal = x.hashCode( );
        hashVal %= TABLE_SIZE;
        if (hashVal < 0)
            hashVal += TABLE_SIZE;
        return hashVal;
    }
   /* Function myhash function for double hashing */
    private int myhash2(String x )
    {
        int hashVal = x.hashCode( );
        hashVal %= TABLE_SIZE;
        if (hashVal < 0)
            hashVal += TABLE_SIZE;
        return primeSize - hashVal % primeSize;
    }
   /* Function to print hash table */
    public void printHashTable()
    {
        System.out.println("\nHash Table");
        for (int i = 0; i < TABLE_SIZE; i++)
            if (table[i] != null)
                System.out.println(table[i].key +" "+table[i].value);
    }
}

/* Class DoubleHashingHashTableTest */
public class DoubleHashingHashTableTest
{
    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);
        System.out.println("Hash Table Test\n\n");
        System.out.println("Enter size");
       /* Make object of HashTable */
        HashTable ht = new HashTable(scan.nextInt() );
        char ch;
       /*  Perform HashTable operations  */
        do
            {
                System.out.println("\nHash Table Operations\n");
                System.out.println("1. insert ");
                System.out.println("2. remove");
                System.out.println("3. get");
                System.out.println("4. check empty");
                System.out.println("5. clear");
                System.out.println("6. size");
                int choice = scan.nextInt();
                switch (choice)
                    {
                    case 1 :
                        System.out.println("Enter key and value");
                        ht.insert(scan.next(), scan.nextInt() );
                        break;
                    case 2 :
                        System.out.println("Enter key");
                        ht.remove( scan.next() );
                        break;
                    case 3 :
                        System.out.println("Enter key");
                        System.out.println("Value = "+ ht.get( scan.next() ));
                        break;
                    case 4 :
                        System.out.println("Empty Status " +ht.isEmpty());
                        break;
                    case 5 :
                        ht.makeEmpty();
                        System.out.println("Hash Table Cleared\n");
                        break;
                    case 6 :
                        System.out.println("Size = "+ ht.getSize() );
                        break;
                    default :
                        System.out.println("Wrong Entry\n ");
                        break;
                    }
               /* Display hash table */
                ht.printHashTable();
                System.out.println("\nDo you want to continue (Type y or n)\n");
                ch = scan.next().charAt(0);
            }
        while (ch == 'Y'|| ch == 'y');
    }
}

Output: