📜  在不使用指针的情况下在 C++ STL 中实现分离链接的程序

📅  最后修改于: 2021-10-27 06:53:26             🧑  作者: Mango

先决条件:分离链,C++ 中的 STL

本文借助 C++ 中的 STL 实现了散列中的分离链接,而不使用指针。

方法:创建一个向量数组来为每个哈希索引获取一个动态(可调整大小)数组,而不是使用链表来做同样的事情。现在在不使用链表的情况下处理数据集变得更容易。这个简单的技巧更容易实现并且效率更高。在这种方法中:

  1. Hash 的大小由类的构造函数初始化。
  2. 根据表达式将元素插入 Hash 中:
    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
    

    使用 STL 单独链接

    算法:该方法的算法如下所述:

    1. 初始化向量的大小(比如n )。
    2. 添加元素时,请执行以下步骤:
      1. 获取 x=”[value] MOD n “的值。
      2. 在 v[x] 中推回这个元素的值。
    3. 对于删除,我们按照以下步骤操作:
      1. 获取 x=”[value] MOD n “的值。
      2. 在 v[x] 中扫描要删除的元素。
      3. 如果找到,则使用 erase() 方法删除元素。
      4. 如果没有找到要删除的元素,打印“Element not found!”
    4. 打印哈希。

    执行

    // C++ Program to implement Separate
    // Chaining in C++ STL without
    // the use of pointers
      
    #include 
    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 > 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 >(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;
    }
    
    输出:
    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
    

    使用这种方法的优点:

    1. 我们不需要像使用链表那样遍历条目。
    2. 更容易调试代码。
    3. 更容易实现,因为传统方法有机会用较小的逻辑错误来标记分段错误。
    4. 在数据上应用 STL 方法的能力,这在竞争性编程中提供了优势。

    如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程。