带有示例的 C++ 中的无序向量集

什么是无序集？

在 C++ 中，无序集是一个无序容器，可以容纳许多唯一元素。与集合不同，无序集合中的元素不按任何特定顺序排列。在内部，无序集是使用散列表实现的，其中键被散列到散列表的索引中，这就是为什么插入总是随机的。 unordered_set 上的所有操作平均花费恒定时间 O(1)，但在最坏的情况下它可能会上升到线性时间 O(n)，这也取决于内部使用的哈希函数。

unordered_set 可以包含任何类型的键——预定义或用户定义的数据结构，但是当我们定义用户定义类型的键时，我们需要根据将比较哪些键来指定我们的比较函数。

与无序集相关的函数：

• insert() :在 unordered_set 容器中插入一个新的 {element}。
• begin() ：返回一个指向 unordered_set 容器中第一个元素的迭代器。
• end() ：返回一个指向过去结束元素的迭代器。
• count() ：计算 unordered_set 容器中特定元素的出现次数。
• find() ：在容器中搜索一个元素。
• clear() ：从 unordered_set 中删除所有元素并将其清空。

什么是向量？

在 C++ 中，向量类似于具有调整自身大小的动态数组。向量的元素存储在连续的内存位置，也可以在迭代器的帮助下访问它们。

与向量相关的一些函数如下所述：

• begin() ：返回一个指向向量中第一个元素的迭代器
• 结尾（）： 返回指向向量中最后一个元素之后的理论元素的迭代器
• rbegin() ：返回一个反向迭代器，指向向量中的最后一个元素（反向开始）。它从最后一个元素移动到第一个元素
• rend() ：返回一个反向迭代器，指向向量中第一个元素之前的理论元素（被认为是反向结束）
• cbegin() ：返回一个指向向量中第一个元素的常量迭代器。
• cend() ：返回一个常量迭代器，指向向量中最后一个元素之后的理论元素。
• crbegin() ：返回一个常量反向迭代器，指向向量中的最后一个元素（反向开始）。它从最后一个元素移动到第一个元素。
• crend() ：返回一个常量反向迭代器，指向向量中第一个元素之前的理论元素（被视为反向端）。

什么是无序向量集？

无序集向量是用于将唯一向量保存在一起的无序关联容器。如果向量的对应元素相等，则认为两个向量相同。
与一组向量不同，向量在一组无序的向量中没有以任何特定的顺序排列。默认情况下，C++ 没有为我们提供创建无序向量集的工具。我们需要传递一个散列函数，使用它可以轻松创建一组无序的向量。

句法：

unordered_set, hashFunction> myUnorderedSet;

Here,

dataType: A data type. It represents the type of value stored by each vector in the unordered set.

hashFunction:

       struct hashFunction 
      {
         size_t operator()(const vector &myVector) const 
         {
             std::hash hasher;
             size_t answer = 0;
             for (int i : myVector) 
            {
                answer ^= hasher(i) + 0x9e3779b9 + 
                                  (answer << 6) + (answer >> 2);
           }
           return answer;
       }
   };

Note:
One can customize the hash function according to the need but the above hash function is quite efficient to handle collisions.

示例 1：下面是整数类型的无序向量集的 C++ 程序。

C++

// C++ program to demonstrate the 
// working of unordered set of vectors
#include 
using namespace std;
  
// Hash function
struct hashFunction 
{
  size_t operator()(const vector 
                    &myVector) const 
  {
    std::hash hasher;
    size_t answer = 0;
      
    for (int i : myVector) 
    {
      answer ^= hasher(i) + 0x9e3779b9 + 
                (answer << 6) + (answer >> 2);
    }
    return answer;
  }
};
  
// Function to iterate over 
// vector elements
void printVector(vector myVector)
{
  cout << "[ ";
  for(auto element : myVector)
    cout << element << ' ';
  cout << "]\n";
}
  
// Function to iterate over unordered 
// set elements
void print(unordered_set, 
           hashFunction> &unorderedsetOfVectors)
{
  for (auto it = unorderedsetOfVectors.begin();
       it != unorderedsetOfVectors.end();
       it++) 
  {
    // Each element is a vector
    printVector(*it);
  }
}
  
// Driver code
int main()
{
  // Declaring a unordered set of vectors
  // Each vector is of integer type
  // We are passing a hash function as 
  // an argument to the unordered set
  unordered_set, 
  hashFunction> unorderedsetOfVectors;
  
  // Initializing vectors
  vector myVector1 {3, 6, 9, 10};
  vector myVector2 {5, 10, 11, 7};
  vector myVector3 {3, 6, 9, 10};
  vector myVector4 {1, 9, 11, 22};
  vector myVector5 {50, 20, 30, 40};
  
  // Inserting vectors into unorderedset
  unorderedsetOfVectors.insert(myVector1);
  unorderedsetOfVectors.insert(myVector2);
  unorderedsetOfVectors.insert(myVector3);
  unorderedsetOfVectors.insert(myVector4);
  unorderedsetOfVectors.insert(myVector5);
  
  // Calling print function
  print(unorderedsetOfVectors);
  
  return 0;
}

输出：

[ 50 20 30 40 ]
[ 1 9 11 22 ]
[ 3 6 9 10 ]
[ 5 10 11 7 ]

解释：

上例中的 Vector1 和 vector3 相同。由于无序集仅包含唯一元素，因此它仅在无序集中打印一次。另外，请注意无序集没有遵循任何特定的元素顺序。

示例 2：下面是一组布尔类型的无序向量的 C++ 程序。

C++

// C++ program to demonstrate the 
// working of unordered set 
// of vectors
#include 
using namespace std;
  
// Hash function
struct hashFunction 
{
  size_t operator()(const vector 
                    &myVector) const 
  {
    std::hash hasher;
    size_t answer = 0;
    for (int i : myVector) 
    {
      answer ^= hasher(i) + 0x9e3779b9 + 
                (answer << 6) + (answer >> 2);
    }
    return answer;
  }
};
  
// Function to iterate over 
// vector elements
void printVector(vector myVector)
{
  cout << "[ ";
  for(auto element : myVector)
    cout << element << ' ';
  cout << "]\n";
}
  
// Function to iterate over unordered 
// set elements
void print(unordered_set,
           hashFunction> &unorderedsetOfVectors)
{
  for (auto it = unorderedsetOfVectors.begin();
       it != unorderedsetOfVectors.end();
       it++)
  {
    // Each element is a vector
    printVector(*it);
  }
}
  
// Driver code
int main()
{
  // Declaring a unordered set of vectors
  // Each vector is of bool type
  // We are passing a hash function as 
  // an argument to the unordered set
  unordered_set, 
  hashFunction> unorderedsetOfVectors;
  
  // Initializing vectors of bool type
  vector myVector1 
  {true, true, true, true};
  vector myVector2 
  {false, false, false, false};
  vector myVector3 
  {true, true, true, false};
  vector myVector4 
  {true, true, false, false};
  vector myVector5 
  {true, true, false, true};
  vector myVector6 
  {true, true, true, true};
  
  // Inserting vectors into unordered set
  unorderedsetOfVectors.insert(myVector1);
  unorderedsetOfVectors.insert(myVector2);
  unorderedsetOfVectors.insert(myVector3);
  unorderedsetOfVectors.insert(myVector4);
  unorderedsetOfVectors.insert(myVector5);
  unorderedsetOfVectors.insert(myVector6);
  
  // Calling print function
  print(unorderedsetOfVectors);
  
  return 0;
}

输出：

[ 1 1 0 1 ]
[ 1 1 0 0 ]
[ 1 1 1 0 ]
[ 1 1 1 1 ]
[ 0 0 0 0 ]

解释：

上例中的 Vector1 和 vector6 相同。由于无序集仅包含唯一元素，因此它仅在无序集中打印一次。另外，请注意无序集没有遵循任何特定的元素顺序。