Open and Closed Hashing in Java

In this article, we are going to learn about Open Hashing and Closed Hashing in the Java programming language. By the end of the article, we will cover different parts of the topic, such as why these techniques are used in the Java programming language, what are the advantages and disadvantages of using these techniques and the differences between Open Hashing and Closed Hashing.

Collision Handling Techniques:

If two pieces of data share the same value in a hash table, then it is known as a collision in hashing. As the key of hash function is a small number for a key which is either a big integer or a string, then probably the two keys result in the same value. So, a collision is also known as a situation a where the newly inserted keys maps with the location of an already occupied position in the hash table. These collisions are handled using different techniques known as collision handling techniques. These techniques are also known as Collision Resolution techniques.

The techniques that are used to handle or resolve the collisions are basically classified into two types. They are:

Open Hashing ( or ) Separate Chaining
Closed Hashing ( or ) Open Addressing

Open Hashing:

The first Collision Resolution or Handling technique, " Open Hashing ", is popularly known as Separate Chaining. This is a technique which is used to implement an array as a linked list known as a chain. It is one of the most used techniques by programmers to handle collisions. Basically, a linked list data structure is used to implement the Separate Chaining technique. When a number of elements are hashed into the index of a single slot, then they are inserted into a singly-linked list. This singly-linked list is the linked list which we refer to as a chain in the Open Hashing technique.

We can make use of a key " K " to search the chain by traversing linearly. If the key K and intrinsic key for any entry in the singly linked list are found to be equal, then it means that we have found our entry. But in a case where we traverse the singly linked list and reach the end without finding our entry, then it means that the entry we are trying to find does not exist.

So, when there are two keys that are fighting for the same key position, then the same key position will be allotted for both keys or records. The key position is furtherly extended after placing one key with a linked list. In the end, the hash table will contain a chain where the collision has happened. That is the main reason for calling this technique as " Chaining technique ".

Advantages of Open Hashing:

The Separate chaining method is simple to implement and understand.
The hash table never ends, so we can add new elements always.
Open Hashing is less sensitive to the load factors or hash function.
It can be implemented when we do not know how frequently keys will be inserted or deleted.

Disadvantages of Open Hashing:

The cache performance of the Separate Chaining method is poor as the keys are stored using a singly linked list.
A lot of storage space is wasted as some parts of the hash table are never used.
In the worst case, the search time can become " O ( n ) ". This happens only if the chain becomes too lengthy.
Extra storage is used for storing links of the chain.

Data Structures used in Open Hashing:

ArrayList
- Search : O ( l ), where l is the length of the array.
- Delete : O ( l )
- Insert : O ( l )
- It is Cache friendly
Linked List
- Search : O ( l ), where l is the length of the Linked List.
- Delete : O ( l )
- Insert : O ( l )
- It is not Cache friendly.
Self-Balancing Binary Search Tree
- Search : O ( log ( l )), where l is the length of the linked list.
- Delete : O ( log ( l ))
- Insert : O ( l )
- It is not Cache friendly.
- It is used HashMap since Java 8.

A Program to implement Open Hashing:

// This is a Java Program to demonstrate the implementation of Open hashing 
// as a collision handling technique.
import java.util.ArrayList;
import java.util.Objects;

// These are the nodes of chains.
class HashNode<K, V> {
    K key;
    V value;
    final int hashCode;

    // The below is a reference to a successive node.
    HashNode<K, V> next;

    // Below the written piece of code is a Constructor.
    public HashNode(K key, V value, int hashCode)
    {
        this.key = key;
        this.value = value;
        this.hashCode = hashCode;
    }
}

// This is a Class to represent the hash table.
class Map<K, V> {
    // A bucketArray is used to store the array of chains.
    private ArrayList<HashNode<K, V> > bucketArray;

    // The current capacity of the Array List.
    private int numbucks;

    // The current size_of_array of the ArrayList.
    private int size_of_array;

    // Constructor (Initializes capacity, size_of_array and
    // empty chains.
    public Map()
    {
        bucketArray = new ArrayList<>();
        numbucks = 12;
        size_of_array = 0;

        // Create a set of empty chains for implementing Open Hashing.
        for (int i = 0; i < numbucks; i++)
            bucketArray.add(null);
    }

    public int size_of_array() { return size_of_array; }
    public boolean isEmpty() { return size_of_array() == 0; }
    
    private final int hashCode (K key) {
        return Objects.hashCode(key);
    }

    // This implements Hash Function to find the index for a key
    private int getBucketIndex(K key)
    {
        int hashCode = hashCode(key);
        int index = hashCode % numbucks;
        // key.hashCode() may result negative.
        index = index < 0 ? index * -1 : index;
        return index;
    }

    // This is the Method to remove any given key.
    public V remove(K key)
    {
        // Apply Hash Function to find index for any given key
        int bucketIndex = getBucketIndex(key);
        int hashCode = hashCode(key);
        // Get head of the chain
        HashNode<K, V> head = bucketArray.get(bucketIndex);

        // To search for any key in its chain
        HashNode<K, V> prev = null;
        while (head != null) {
            // If Key found
            if (head.key.equals(key) && hashCode == head.hashCode)
                break;

            // Else keep moving in chain
            prev = head;
            head = head.next;
        }

        // If the key is not present.
        if (head == null)
            return null;

        // size of the array is decremented.
        size_of_array--;

        
        if (prev != null)
            prev.next = head.next;
        else
            bucketArray.set(bucketIndex, head.next);

        return head.value;
    }

    // This returns the value for any key.
    public V get(K key)
    {
        // Find head of chain for a given key.
        int bucketIndex = getBucketIndex(key);
        int hashCode = hashCode(key);
    
        HashNode<K, V> head = bucketArray.get(bucketIndex);

        // To search for key in the chain.
        while (head != null) {
            if (head.key.equals(key) && head.hashCode == hashCode)
                return head.value;
            head = head.next;
        }

        // If the requried key is not found, then
        return null;
    }

    // Adds a key value pair to the hash
    public void add(K key, V value)
    {
        // Find head of the chain for any given key.
        int bucketIndex = getBucketIndex(key);
        int hashCode = hashCode(key);
        HashNode<K, V> head = bucketArray.get(bucketIndex);

        // Check if the key already exists.
        while (head != null) {
            if (head.key.equals(key) && head.hashCode == hashCode) {
                head.value = value;
                return;
            }
            head = head.next;
        }

        // Increment the size of array.
        size_of_array++;
        head = bucketArray.get(bucketIndex);
        HashNode<K, V> newNode
            = new HashNode<K, V>(key, value, hashCode);
        newNode.next = head;
        bucketArray.set(bucketIndex, newNode);

        /*  If the load factor goes beyond threshold, then
         double hash table size_of_array */
        if ((1.0 * size_of_array) / numbucks >= 0.7) {
            ArrayList<HashNode<K, V> > temp = bucketArray;
            bucketArray = new ArrayList<>();
            numbucks = 2 * numbucks;
            size_of_array = 0;
            for (int i = 0; i < numbucks; i++)
                bucketArray.add(null);

            for (HashNode<K, V> headNode : temp) {
                while (headNode != null) {
                    add(headNode.key, headNode.value);
                    headNode = headNode.next;
                }
            }
        }
    }

    // Driver method to test Map class
    public static void main(String[] args)
    {
        Map<String, Integer> map = new Map<>();
        map.add("Hello", 1);
        map.add("programmer", 2);
        map.add("Hello", 4);
        map.add("Manager", 5);
        System.out.println(map.size_of_array());
        System.out.println(map.remove("Hello"));
        System.out.println(map.remove("Hello"));
        System.out.println(map.size_of_array());
        System.out.println(map.isEmpty());
    }
}

Output:

3
4
null
2
false

There are different functions embedded within the Open hashing which are used in the implementation of Separate Chaining in the above program. Let us see what these functions are and how they are useful in the process of Open Hashing.

Functions Used in Open Hashing:

get(K key): If the key is present in HT, get(K key) gives the value corresponding to the key (Hast Table).
getSize(): It will return the size of the hash table.
add(): Changes an existing valid key-value pair in the HT if it already exists before adding a new one.
remove(): The remove function will remove both the and the value pair.
isEmpty(): it returns the value " True ", if the size is zero.

Now, we will see the detailed implementation of these functions to get a better understanding and picturization of the program.

Implementation of the Functions:

get(): The function " get() " simply accepts a key as input and, if the key is available in the table, returns the matching value; otherwise, it returns null. The steps in the implementation of the get() function are:
- To locate the index in the HT, get the input key.
- If you fully traverse the list without returning, it signifies the value is not there in the table and cannot be fetched, so return null. Traverse the linked list corresponding to the HT.
remove():
- Use the helper function to retrieve the index that corresponds to the input key.
- Similar to how the get() traverses a linked list, this method requires removing the key in addition to finding it, which creates two situations.
- If the key that has to be deleted is at the head of the linked list.
- If the key that has to be removed is not at the head but rather somewhere else.
add(): The function " add() " is the most fascinating and difficult part of the entire execution. It is intriguing because when the load factor exceeds the figure we set, we must dynamically expand the size of our list.
- Similar to adding and subtracting steps until traversal, two scenarios (addition at the head spot or non-head spot) do not change.
- If the value of the load factor is more than 0.7 at the conclusion, We increase the array list's size by two and then recursively use the add() method on the already-existing keys because the array's size is used to compress the internal JVM hash code in our scenario, and we must obtain new indices for the keys that are already present.

Note: If " n " is the total number of cells in the chain that we initially intended to fill, let's say 10, and let's also say that 7 of those cells are now filled, then the load factor is 7/10, i.e. 0.7.

So, this is the Open Hashing technique used in resolving a collision in a hash table. Now, let us see and understand the Closed Hashing technique.

Closed Hashing:

The second most Collision resolution technique, Closed Hashing, is a way of dealing with collisions, similar to the Separate Chaining process. In Open Addressing, the hash table alone stores all of its elements. The size of the table should always be greater than or equal to the total number of keys at all times ( we can also increase the size of the table by copying the old data that is already existing whenever it is needed ). This mechanism is referred to as Closed Hashing. The formation and consideration of the whole process is probing.

Functions Used in Closed Hashing:

Insert( k ): Up till a space is left unfilled, keep probing. Place the key " k " in the first empty slot you find.
Search( k ): Probe each slot until the key is not equal to k or until an empty slot is found.
Delete( k ): It's interesting to delete something. The search may fail when we just remove a key and then perform search operation. The slots that are a part of deleted key slots are considered as "deleted."

Several techniques to perform Implementation of Closed Hashing:

1. Linear Probing: In linear probing, the hash table undergoes clear and neat examination, starting from the hash's initial or beginning point. If the slot that is obtained after the calculation is already occupied, then we should look for a different one. The function that is responsible for performing rehashing is " key = rehash(n+1)%table-size ". The space between the two probes or positions is generally 1.

Let us see Linear Probing for a slot index " hash(a) ", which is computed using a hash function. It is one of the best techniques which has the best cache performance.

Difficulties faced with Linear Probing:

Primary Clustering: Primary clustering is one of the major issues that are caused with the linear probing technique. Many elements that are consecutive to each other generally form clusters or a group of scattering, which in turn makes the hash table more difficult to find an empty slot or search for an element.
Secondary Clustering: Secondary clustering is not as severe as primary clustering, and the elements or records that must be placed within the same location are only allowed to share a collision chain which is also known as a probe sequence, if they begin at the same location.
Clustering is the only problem in Linear probing. If clustering can be reduced within this mechanism, then this can be considered one of the best Collision resolution techniques.

2. Quadratic Probing: In Quadratic Probing, the intervals between the key positions is increased when compared to linear probing as the hash function is mostly different. The issue that is occurred due to the clustering in the above technique can be easily solved by using the quadratic probing technique. This technique is also known as mid-square method. When the iteration that is currently running is " i ", then the i^2th position is considered as the key position for that respective key. Other slots of positions are checked only when the key position that we are trying for is already occupied. This is the most efficient and effective method for a hash table which possesses closed properties. It has an average performance of cache and a subtle problem with clustering.

Difficulties faced with Quadratic Probing:

It deals with secondary clustering, and sometimes, two keys have same prob sequence whenever they possess the same key position.

3. Double hashing

In this resolution technique, another hash function is used, which is created especially for the Double hashing mechanism. In this technique, the clustering that is formed between the keys is handled efficiently and is further reduced. The increment of the key positions is made out of the function that will be used in this mechanism. With that function, the key positions are calculated with their respective keys and are placed in the positions accordingly. The function is then multiplied with the variable " i ", and then the modulo operation is performed.

Difficulties in Double hashing:

Compared to other techniques, double hashing possesses poor cache performance but does not have any clustering issues. The time required for the completion of the entire process is more as there are two hash functions that are supposed to be performed. So, this causes poor cache performance. Other than this, there is no problem with Double hashing.

A Program to implement Closed Hashing:

// program that determines
// hash table implementation
// representing the closed hashing

public class A
{

    // presenting the properties
    // of the hash table
     
    private int max = 20;

    private HashTableNode[] vector = new HashTableNode[max];

    // presenting the element
    // of the hashtable

    class HashTableNode 
    {
        // declaration
        // of the
        // required variables

        public int key;

        HashTableNode(int key) 
        {

            this.key = key;
        }
    }

    // initiating the constructor 
    // method in order to access it
    // with ease
    A() 
    {

        for (int i = 0; i < max; i++) 
        {
            
            this.vector[i] = null;
        }
    }

    // add the method
    // proceeding with the 
    // addition of elements to
    // the hash table
    // consider an integer key
    // return to void
    
    public void add(int key, int i) 
    {

        int hashcode = this.h(key, i);

        if ((i > 0) && (hashcode == this.h(key, 0))) {

            System.out.println("The key" + key +" cannot be added into the hash table !!");
            return;
        }

        if (this.vector[hashcode] != null) {
            
            this.add(key, i + 1);
        }
        else {

            this.vector[hashcode] = new HashTableNode(key);
        }
    }

    
    // the method add() is 
    // being overloaded and the 
    // call of the method 
    // is simplified
    
    public void add(int key) 
    {

        this.add(key, 0);
    }

    // search a method and
    // also search for an element 
    // using the hash table

    public int search(int key, int i) 
    {

        int hashcode = this.h(key, i);

        if ((i > 0) && (hashcode == this.h(key, 0))) 
        {

            System.out.println("The key " + key + " is not found in the hash table. It has done " + i + " stepsizes.");

            return -99;
        }

        if ((this.vector[hashcode] != null) && (this.vector[hashcode].key == key)) 
        {

            System.out.println("The key " + key + " is found in the hash table in " + (i + 1) + "-esim stepsize.");

            return hashcode;
        }
        
        return this.search(key, i + 1);
    }

    // overloading the seach method
    // which in turn simplifies the
    // call of the method
    public int search(int key) 
    {

        return this.search(key, 0);
    }

    
    // the remove method
    // removes the element 
    // that is selected
    // from the hash table
    public void remove(int key) 
    {

        int i = this.search(key);

        if (i != -99) {
            
            System.out.println("The key or the element " + key + " is removed from the hash table.");

            this.vector[i] = null;
        }
        else {

            System.out.println("The key " + key + " is not removed as the element does not exist in a hash table.");
        }
    }

    // the method h_linear
    // which performs linear probing
    public int h_linear(int key, int i) 
    {

        return (key + i) % this.max;
    }

    // the method h_quadratic
    // which performs quadratic probing
    public int h_quadratic(int key, int i) 
    {

        return (key + (i * i)) % this.max;
    }

    // the method h_double
    // which performs double hashing
    public int h_double(int key, int i) 
    {

        return (this.h_double2(key) + i) % this.max;
    }

    // second function that is involved
    // in double hashing is represented by 
    // this method
    public int h_double2(int key) 
    {

        return (1 + key) % (this.max - 1);
    }

    // hash function representation
    public int h(int key, int i) 
    {

        return this.h_linear(key, i);
    }

    // the method toString provides
    // the functionality of some of 
    // the visuals in order to see
    // the elements present within 
    // the hash table 

    // It aslo denotes the 
    // representation of the
    // hash table by a string 
    // for an instance
    
    public String toString() 
    {

        String description = "Hash table: [ ";

        for (int i = 0; i < this.max; i++) 
        {
            
            if (this.vector[i] == null) 
            {
                
                description += "__  ";
            }
            else {

                description += String.format("%2d  ", this.vector[i].key);
            }
        }

        description += "]";

        return description;
    }
     // declaration of the
    // main method in the 
    // class " A " 
    public static void main(String args[])
    {
        // creation of an 
        // object in the 
        // main class " A "
        A obj = new A();

        // the object that is created
        // is accessing the add method 
        // in order to add a new element
        obj.add(228, 1);
        obj.add(567, 2);

        // accessing the remove method
        obj.remove(246);
    }
}

Output:

The key 246 is not found in the hash table. It has done 20 step sizes.
The key 246 is not removed as the element does not exist in a hash table.

Overview of Open hashing and Closed hashing:

Open hashing is mostly used in order to avoid complexity within the implementation and complete the work in an easy way, whereas Closed hashing deals with more complexity and computation. Open hashing has no outline or boundary of elements or keys or records that can be inserted within. Unlimitedly, the records can be entered when Open hashing is used. Closed hashing is bound with some limited records in which some records may not have enough key positions left for their entry. In Open hashing, extra storage or space is created irrespective of the table size. This storage is used in situations where a collision occurs. This type of mechanism is not performed in Closed hashing as the entire table is the only source for the records to be placed, and no external storage is added.

Next TopicDAO Class in Java

← prev next →