Program to implement Separate Chaining in C++ STL without the use of pointers

Pre-requisite: Separate Chaining, STL in C++

This article implements the Separate Chaining in Hashing with help of STL in C++ without the use of pointers.

Approach: Make an array of vectors to get a dynamic (resizable) array for every hash index rather than using a linked list to do the same. Now it becomes easier to work on the data-set without using linked list. This simple trick is much easier to implement and is more efficient. In this approach:

  1. The size of the Hash is initialized by the constructor of the class.
  2. The elements are inserted in the Hash according to the expression:
    Vector[i % n].push_back(i);
    where:
        Vector = the array of vectors used for hash
        i = current element to be hashed
        n = size of the hash
    

    Separate Chaining using STL

    Algorithm: The algorithm for the approach is mentioned below:

    1. Initialize the size (say n) of vectors.
    2. While adding an element, go through the following steps:
      1. Get the value of x=”[value] MOD n“.
      2. Push back this element’s value in the v[x].
    3. For Deletion, we follow these steps:
      1. Get the value of x=”[value] MOD n“.
      2. Scan for the element to be deleted in v[x].
      3. If found, remove the element using erase() method.
      4. If element to be deleted is not found, print “Element not found!”
    4. Print the hash.

    Implementation



    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // C++ Program to implement Separate
    // Chaining in C++ STL without
    // the use of pointers
      
    #include <bits/stdc++.h>
    using namespace std;
      
    // Container for our data-set
    class SeperateHash {
      
        // Data members are kept private
        // since they are accessed using methods
    private:
        int n;
        vector<vector<int> > v;
      
        // Methods are kept public
    public:
        // Initialising constructors as the
        // minimum required memory will be
        // allocated after which compiler
        // will not report flag error
        SeperateHash(int n)
        {
            // Constructor to initialize
            // the vector of vectors
            v = vector<vector<int> >(n);
      
            // Here, we will allocate
            // memory of the unnamed_memory
            // to the object. This snippet
            // of code won't work for now.
            // Program will work whenever
            // constructor gets initialized
            this->n = n;
        }
      
        int getHashIndex(int x)
        {
            return x % n;
        }
      
        void add(int x)
        {
            // Adding the element according
            // to hash index
            v[getHashIndex(x)].push_back(x);
        }
      
        void del(int x)
        {
            int i = getHashIndex(x);
      
            // Scan for the element to be removed
            for (int j = 0; j < v[i].size(); j++) {
      
                // Erase if present otherwise
                // print no element found!
                if (v[i][j] == x) {
                    v[i].erase(v[i].begin() + j);
                    cout << x << " deleted!" << endl;
                    return;
                }
            }
      
            cout << "No Element Found!" << endl;
        }
        void displayHash()
        {
            // Display the contents
            for (int i = 0; i < v.size(); i++) {
                cout << i;
                for (int j = 0; j < v[i].size(); j++)
                    cout << " -> " << v[i][j];
                cout << endl;
            }
        }
    };
      
    // Driver Code
    int main()
    {
        // Array to be used
        int arr[] = { 12, 3, 23, 4, 11,
                      32, 26, 33, 17, 19 };
      
        // Sending the size
        // for separate chaining
        SeperateHash obj(10);
      
        // Inserting elements in
        // the container accordingly
        for (int i = 0; i < 10; i++)
            obj.add(arr[i]);
      
        // Display the initial hash
        cout << "Initial Hash:\n";
        obj.displayHash();
      
        // Removing the element
        // from the container
        cout << "\nRemoving 23 from Hash: ";
        obj.del(23);
        cout << endl;
      
        // Display the final hash
        cout << "Final Hash:\n";
        obj.displayHash();
        return 0;
    }

    chevron_right

    
    

    Output:

    Initial Hash:
    0
    1 -> 11
    2 -> 12 -> 32
    3 -> 3 -> 23 -> 33
    4 -> 4
    5
    6 -> 26
    7 -> 17
    8
    9 -> 19
    
    Removing 23 from Hash: 23 deleted!
    
    Final Hash:
    0
    1 -> 11
    2 -> 12 -> 32
    3 -> 3 -> 33
    4 -> 4
    5
    6 -> 26
    7 -> 17
    8
    9 -> 19
    

    Advantages of using this approach:

    1. We don’t need to iterate through the entries like we need to with linked lists.
    2. Easier debugging of code.
    3. Easier to implement since the conventional approach has chances of flagging segmentation fault with minor logical errors.
    4. Power of applying STL methods over the data which provides an edge in competitive programming.

    Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




    My Personal Notes arrow_drop_up

    Check out this Author's contributed articles.

    If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

    Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.