Java Program to Implement Hash Tables with Double Hashing

12 Nov, 2021
Double hashing is a technique in an open addressing scheme. and there is the ordinary hash function. In an open addressing scheme, the actual hash function is taking the ordinary hash function when its space is not empty then it will perform another hash function to get some space to insert. Double hashing is a collision resolving technique in an Open Addressed Hash tables. It uses the idea of applying a second hash function (myhash2) as mentioned in the code to the key when a collision occurs.
It is the technique that is used in open addressing. In this, we will use two hash functions. The first function used, is similar to linear probing(Linear probing is a scheme in computer programming for resolving collisions in hash tables, data structures for maintaining a collection of key-value pairs and looking up the value associated with a given key), table size or the “key-mod” but if the collision occurs, then the second hash function is applied.
Note: It is used in open addressing, in which we used to hash function. The first  function is used as same in linear probing (HASH_TABLE_SIZE or key-mod) but if the collision occur then the second hash function can be applied.
There are two conditions we need to keep in mind.
Our second hash function never evaluates to zero.
It must be reachable to cells i.e. all cells must probe first.
Algorithm:
h1(key) = key% hash_table_size
h2(key) = PM-(key%PM)*PM 
// where PM is prime number
Implementation:
Example
Java
// Java Program to implement hashtable in// double hashing // Importing input output classesimport java.io.*; // Class 1// Helper Class// LinkedHashEntryclass ValueEntry {     // Member variables of the class    String key;    int value;     // Constructor of this class    // Parameterized constructor    ValueEntry(String key, int value)    {        // This keyword refers to current object        // for assigning values to same object itself        this.key = key;         // this operator is pointer which contains location        // of  that container that have key and value pairs        this.value = value;    }} // Class 2// Helper Class//  HashTableclass HashTable {     // Member variable of this class    private int HASH_TABLE_SIZE;    private int size;    private ValueEntry[] table;    private int totalprimeSize;     // Constructor of this class    // Parameterized constructor    public HashTable(int ts)    {        // Initializing the member variables        size = 0;        HASH_TABLE_SIZE = ts;        table = new ValueEntry[HASH_TABLE_SIZE];         // Iterating using for loop over table        for (int i = 0; i < HASH_TABLE_SIZE; i++)            table[i] = null;        totalprimeSize = getPrime();    }     // Method 1    // To check for the prime number    public int getPrime()    {        // Iterating using for loop in reverse order        for (int i = HASH_TABLE_SIZE - 1; i >= 1; i--) {             // Initially assigning count to zero            int cnt = 0;             // Now, iterating from 2 upto the desired number            // to be checked by dividing it with all no            // in between [2 - no]            for (int j = 2; j * j <= i; j++)                 // If number is divisible                // means not a prime number                if (i % j == 0)                     // So simply move to next number                    // to check for divisibility by                    // incrementing the count variable                    cnt++;             // By now number is not divisible            // hence count holds 0 till last            if (cnt == 0)                 // It means it is a prime number so                // return the number as it is a prime number                return i;        }         // Returning a prime number        return 3;    }     // Method 2    // 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 < HASH_TABLE_SIZE; i++)            table[i] = null;    }     // Method 3    // To get value of a key    public int getkey(String key)    {        int hash1 = myhash1(key);        int hash2 = myhash2(key);         while (table[hash1] != null               && !table[hash1].key.equals(key)) {            hash1 += hash2;            hash1 %= HASH_TABLE_SIZE;        }        return table[hash1].value;    }     // Method 4    // To insert a key value pair    public void insert(String key, int value)    {        // checking the size of table and        //  comparing it with users input value        if (size == HASH_TABLE_SIZE) {             // Display message            System.out.println("Table is full");            return;        }         int hashing1 = myhash1(key);        int hashing2 = myhash2(key);        while (table[hashing1] != null) {            hashing1 += hashing2;            hashing1 %= HASH_TABLE_SIZE;        }         table[hashing1] = new ValueEntry(key, value);        size++;    }     // Method 5    // 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 %= HASH_TABLE_SIZE;        }        table[hash1] = null;        size--;    }     // Method 6    // Function gives a hash value for a given    // string basically it is linear probing    private int myhash1(String y)    {        int myhashVal1 = y.hashCode();        myhashVal1 %= HASH_TABLE_SIZE;        if (myhashVal1 < 0)            myhashVal1 += HASH_TABLE_SIZE;        return myhashVal1;    }     // Method 7    // Remember that the above function namely 'myhash'    // is used for double hashing     // Now after linear probing, quadratic probing    //  is used in which two myhash functions are used    //  as it is double chaining    private int myhash2(String y)    {        int myhashVal2 = y.hashCode();        myhashVal2 %= HASH_TABLE_SIZE;        if (myhashVal2 < 0)            myhashVal2 += HASH_TABLE_SIZE;        return totalprimeSize - myhashVal2 % totalprimeSize;    }     // Method 8    // To print the hash table    public void printHashTable()    {        // Display message        System.out.println("\nHash Table");         for (int i = 0; i < HASH_TABLE_SIZE; i++)            if (table[i] != null)                System.out.println(table[i].key + " "                                   + table[i].value);    }} // Class 3// Main class// Class for DoubleHashingHashTableTestpublic class GFG {     // Main driver method    public static void main(String[] args)    {        // Display message        System.out.println("Hash Table Testing");         // Creating an object of HashTable        // in the main() method        // Custom hashtable of size 100        // means 100 key-value pairs the        // above hashtable can hold        HashTable ht = new HashTable(100);         // Inserting custom values to the hashtable        // that is key and value pairs        // Custom inputs        ht.insert("prime", 97);        ht.insert("even", 96);        ht.insert("odd", 95);         // Printing hash table after insertion of        // key value pairs and calling function        // which prints out the hashtable.        //        // Calling the function as usual        // with the help of objects        ht.printHashTable();    }}
  
Hash Table Testing

Hash Table
prime 97
even 96
odd 95
 
Example 2
 
Java
// Java Program to implement hashtable in// double hashing // Here performing additional task// which is to remove the entered items // Importing input output classesimport java.io.*;// Importing all classes from java.util packageimport java.util.*; // Class 1// Class LinkedHashEntryclass ValueEntry {     // Member variables of this class    String key;    int value;     // Constructor of this class    // Parameterized constructor    ValueEntry(String key, int value)    {        // 'This' keyword refers to the current object itself        // to assign the values        this.key = key;                 // This keyword is pointer which contains location        // of  that container that have key and value pairs       this.value = value;    }} // Class 2// Helper class// Class HashTableclass HashTable {     // Member variable of this class    private int HASH_TABLE_SIZE;    private int size;    private ValueEntry[] table;    private int totalprimeSize;     // Constructor of this class    // Parameterized constructor    public HashTable(int ts)    {        // Initially, initializing the parameters        //  to some values        size = 0;        HASH_TABLE_SIZE = ts;        table = new ValueEntry[HASH_TABLE_SIZE];         // Iterating using for loop over table        for (int i = 0; i < HASH_TABLE_SIZE; i++)             // Initially table is empty            table[i] = null;        totalprimeSize = getPrime();    }     // Method 1    // To check  for the prime number    public int getPrime()    {        // Iterating over hashtable using nested for loops        //  in reverse order        for (int i = HASH_TABLE_SIZE - 1; i >= 1; i--) {             // Initially count is zero            int cnt = 0;             for (int j = 2; j * j <= i; j++)                if (i % j == 0)                    cnt++;            if (cnt == 0)                return i;        }        // Returning  a prime number        return 3;    }     // Method 2    // To get snumber of key-value pairs    public int getSize()    { return size; }    public boolean isEmpty()    { return size == 0; }     // Method 3    // To clear the hash table    public void makeEmpty()    {        // Initially size set to zero        size = 0;        for (int i = 0; i < HASH_TABLE_SIZE; i++)            table[i] = null;    }     // Method 3    // To get value of a key    public int getkey(String key)    {        int hash1 = myhash1(key);        int hash2 = myhash2(key);         while (table[hash1] != null               && !table[hash1].key.equals(key)) {            hash1 += hash2;            hash1 %= HASH_TABLE_SIZE;        }        return table[hash1].value;    }     // Method 4    // To insert a key-value pair    public void insert(String key, int value)    {        // Checking the size of table and        // comparing it with users input value        if (size == HASH_TABLE_SIZE) {             // Display message            System.out.println("Table is full");            return;        }         int hashing1 = myhash1(key);        int hashing2 = myhash2(key);         while (table[hashing1] != null) {            hashing1 += hashing2;            hashing1 %= HASH_TABLE_SIZE;        }         table[hashing1] = new ValueEntry(key, value);        size++;    }     // Method 4    // To remove a key from hashtable    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 %= HASH_TABLE_SIZE;        }         table[hash1] = null;        size--;    }     // Method 5    // This method returns a hash value for a given    //  string as it is linear probing    private int myhash1(String y)    {        int myhashVal1 = y.hashCode();        myhashVal1 %= HASH_TABLE_SIZE;        if (myhashVal1 < 0)            myhashVal1 += HASH_TABLE_SIZE;        return myhashVal1;    }     // Method 6    // In this function, 'myhash'function for double hashing    // after linear probing. A quadratic probing is used in    //  which two 'myhash' functions are used    //  as it is double chaining    private int myhash2(String y)    {        int myhashVal2 = y.hashCode();        myhashVal2 %= HASH_TABLE_SIZE;        if (myhashVal2 < 0)            myhashVal2 += HASH_TABLE_SIZE;        return totalprimeSize - myhashVal2 % totalprimeSize;    }     // Method 7    // To print hash table    public void printHashTable()    {        // Display message        System.out.println("\nHash Table");         // Iterating over the table        for (int i = 0; i < HASH_TABLE_SIZE; i++)            if (table[i] != null)                System.out.println(table[i].key + " "                                   + table[i].value);    }} // Class 3// Main class// Class for DoubleHashingHashTableTestpublic class GFG {     // Main driver method    public static void main(String[] args)    {        // Display message        System.out.println("Hash Table Testing");                 // Step 1: Creating an object of hashtable        // of custom size 100 which signifies        // table can hold 100 key-value pairs        HashTable ht = new HashTable(100);         // Step 2: Adding(appending) the values to        // the hashtable object        // Custom inputs of key-value pairs         ht.insert("prime", 97);        ht.insert("even", 96);        ht.insert("odd", 95);                 // Step 3: Printing hash table after insertion        //  of key-value pairs                 // Calling print hash table function using object        // we call it with object.function_name        ht.printHashTable();             // Primarily goal of the program      // Step 4: Removing elements with using key values      // using the remove() method      ht.remove("prime");      ht.printHashTable();    }}
  
Hash Table Testing

Hash Table
prime 97
even 96
odd 95

Hash Table
even 96
odd 95
Similarly, we can get the size of hashed table, can clear the elements from hash table, can get our desired element in hash function. In order to get 
For size can use ht.getSize()
For element can use ht.get(String)
 Where ht is object name. In the same way, we can call our other functions in the above code.
 
sweetyty
akshaysingh98088
saurabh1990aror
gulshankumarar231
rajeev0719singh
kashishsoda
Java-Collections
Java-HashTable
Picked
Technical Scripter 2020
Java
Java Programs
Technical Scripter
Java
Java-Collections
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stream In Java
Introduction to Java
Constructors in Java
Exceptions in Java
Generics in Java
Java Programming Examples
Convert Double to Integer in Java
Implementing a Linked List in Java using Class
Factory method design pattern in Java
Java Program to Remove Duplicate Elements From the Array