Java Program to Implement Hash Tables with Double Hashing
Last Updated :
10 Apr, 2023
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 classes
import java.io.*;
// Class 1
// Helper Class
// LinkedHashEntry
class 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
// HashTable
class 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 DoubleHashingHashTableTest
public 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();
}
}
OutputHash 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 classes
import java.io.*;
// Importing all classes from java.util package
import java.util.*;
// Class 1
// Class LinkedHashEntry
class 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 HashTable
class 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 number 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 DoubleHashingHashTableTest
public 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();
}
}
OutputHash 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.
Similar Reads
Java Program to Implement Hash Table Chaining with List Heads A hash table is a data structure that executes a connected array, it is a structure that maps keys to its values. It uses a hash function to calculate an index position for the keys, also called hash code. It will store key and value pair in an array of buckets, and from that bucket, the values can
4 min read
Java Program to Implement Hash Tables Chaining with Doubly Linked Lists Hash Tables(similar to tables in general) provide a subset of the dynamic set operations. Usually, a set of keys are mapped with some values based on certain relations. However, there might be situations when different keys map to the same position provided by the Hash function, which leads to a col
5 min read
Java Program to Implement HashTable API The Hashtable class implements a hash table, which maps keys to values. Any non-null object can be used as a key or as a value. To successfully store and retrieve objects from a hashtable, the objects used as keys must implement the hashCode method and the equals method. To implement Hashtable API f
4 min read
Java Program to Implement HashTables with Linear Probing Hashing is a technique that is used to uniquely identify a specific object from a group of similar objects. Suppose an object is to be assigned a key to it to make searching easy. To store the key/value pair, one can use a simple array like a data structure where keys (integers) can be used directly
5 min read
Java Program to Implement ConcurrentHashMap API ConcurrentHashMap class obeys the same functional specification as HashTable and includes all the versions of methods corresponding to each method of a HashTable. A HashTable supports the full concurrency of retrievals and adjustable concurrency for updates. All the operations of ConcurrentHashMap a
6 min read
Java Program to Implement IdentityHashMap API The IdentityHashMap implements Map interface using Hashtable, using reference-equality in place of object-equality when comparing keys (and values). This class is not a general-purpose Map implementation. While this class implements the Map interface, it intentionally violates Map’s general contract
6 min read
Hashtable Implementation with equals and hashcode Method in Java To implement a hash table, we should use the hash table class, which will map keys to the values. The key or values of the hash table should be a non-null object. In order to store and retrieve data from the hash table, the non-null objects, that are used as keys must implement the hashCode() method
6 min read
How to Implement a Bidirectional Map Using Two HashSets in Java? Bidirectional maps are also known as two-way maps or dual maps. These provide a convenient way to establish a relationship between keys and values in both directions. In Java, we can implement these using HashSet. So, in this article, we will see how to implement bidirectional maps in Java using two
4 min read
Java Program to Implement LinkedHashMap API The LinkedHashMap is just like HashMap with an additional feature of maintaining an order of elements inserted into it. HashMap provided the advantage of quick insertion, search, and deletion but it never maintained the track and order of insertion which the LinkedHashMap provides where the elements
3 min read
Java Program to Implement LinkedHashSet API The LinkedHashSet is an ordered version of HashSet that maintains a doubly-linked List across all elements. When the iteration order is needed to be maintained, this class is used. When iterating through a HashSet, the order is unpredictable, while a LinkedHashSet lets us iterate through the element
4 min read