无需使用指针即可在C++ STL中实现单独链接的程序

先决条件：单独链接，C++中的STL

本文借助C++中的STL在不使用指针的情况下实现了哈希散列。

方法：制作一个向量数组，以获取每个哈希索引的动态(可调整大小)数组，而不是使用链接列表来执行此操作。现在，无需使用链表就可以更轻松地处理数据集。这个简单的技巧更容易实现，效率更高。在这种方法中：

1. 哈希的大小由类的构造函数初始化。
2. 根据以下表达式将元素插入到哈希中：

   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. 如果找到，请使用delete()方法删除该元素。
      4. 如果找不到要删除的元素，则打印“找不到元素！”。
   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方法的强大功能在竞争性编程中提供了优势。