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

先决条件：分离链，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 现场工作专业课程和学生竞争性编程现场课程。