STL容器之unordered_set类

已于 2024-04-09 10:33:17 修改
阅读量519 收藏 36
点赞数 41
分类专栏： C/C++ 文章标签： c++ 开发语言
于 2024-04-09 10:29:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44121078/article/details/137541675
版权

文章目录


img

STL容器之unordered_set类

1、unordered系列关联式容器

前面在讲map和set有提到过关联式容器，即使用键值对即< Key , Value >的形式来存储和访问数据，按照键值进行组织和查找。在数据检索时比序列式容器效率更高。常见的unordered系列关联式容器包括：

  1. unordered_map: 哈希表实现的键值对集合，查找速度比map快，但是不保证元素的顺序。

  2. unordered_set: 哈希表实现的关键字集合，查找速度比set快，但是不保证元素的顺序。

注意：map和set的结构是树形结构的关联式容器，用的是红黑树作为底层结构。unordered_map和unordered_set的结构是哈希结构的关联式容器，用的是哈希表作为底层结构。

2、unordered_set

2.1、unordered_set介绍

unordered_set的文档介绍

  1. unordered_set是以不特定顺序存储独特元素的容器，并允许根据其值快速检索单个元素。

  2. 在unordered_set中，元素的值同时是其键，唯一标识它。键是不可变的，因此，unordered_set中的元素不能在容器中修改 – 不过，它们可以插入和删除。

  3. 在内部，unordered_set中的元素没有按任何特定顺序排序，而是根据其哈希值组织成桶，以便通过其值直接快速访问单个元素（平均时间复杂度恒定）。

  4. unordered_set容器比set容器更快地通过其键访问单个元素，但是它通常在遍历元素子集的范围迭代方面效率较低。

  5. 容器中的迭代器至少是前向iterators。

2.2、unordered_set的使用

2.2.1、unordered_set的常见构造
(constructor )函数名称接口说明
unordered_set ( size_type n = /* see below */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& alloc = allocator_type() )构造空的unordered_set
unordered_set ( InputIterator first, InputIterator last, size_type n = /* see below */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& alloc = allocator_type() )用[first,last)迭代区间构造unordered_set
unordered_set ( const unordered_set& ust )unordered_set的拷贝构造
void test_us1() {
    unordered_set<int> us;
    int a[]{1, 2, 5, 7, 2, 3, 5, 8, 2, 11, 9};

    for (auto e: a) {
        us.insert(e);
    }
    for (auto e: us) {
        cout << e << " ";
    }
    cout << endl;
    cout << "=======================" << endl;

    unordered_set<int> us1(us.begin(), us.end());
    for (auto e: us1) {
        cout << e << " ";
    }
    cout << endl;
    cout << "=======================" << endl;

    unordered_set<int> us2(us1);
    for (auto e: us2) {
        cout << e << " ";
    }
    cout << endl;

}
2.2.2、unordered_set的迭代器
函数名称接口说明
begin()+end()获取第一个元素位置的iterator和获取最后一个元素的后一个位置的iterator
cbegin()+cend()获取第一个元素位置的const_iterator和获取最后一个元素的后一个位置的const_iterator
void test_us2() {
    unordered_set<int> us;
    int a[]{1, 2, 5, 7, 2, 3, 5, 8, 2, 11, 9};
    for (auto e: a) {
        us.insert(e);
    }
    unordered_set<int>::iterator it = us.begin();
    while (it != us.end()) {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    cout << "=======================" << endl;

    unordered_set<int>::const_iterator it1 = us.cbegin();
    while (it1 != us.cend()) {
        cout << *it1 << " ";
        ++it1;
    }
    cout << endl;
}
2.2.3、unordered_set的容量
函数名称接口说明
empty判断当前unordered_set是否为空
size获取unordered_set的元素个数
void test_us3() {
   unordered_set<int> us;
   int a[]{1, 2, 5, 7, 2, 3, 5, 8, 2, 11, 9};
   for (auto e: a) {
       us.insert(e);
   }
   cout << us.empty() << endl;
   cout << us.size() << endl;

   us.clear();
   cout << us.empty() << endl;
   cout << us.size() << endl;
}
2.2.4、unordered_set的增删查
函数名称接口说明
insert在unordered_set中插入元素x，实际上插入的是<x,x>键值对，如果插入成功，返回<x插入位置,true>，插入失败说明unordered_set中已经有x，返回<x在unordered_set的位置,false>
erase删除unordered_set中pos位置的元素，或者删除值为val的元素
swap交换两个unordered_set的元素
clear将unordered_set的元素置空
find返回unordered_set中值为x的元素位置
count返回unordered_set中值为x的元素个数
void test_us4() {
    unordered_set<int> us;
    int a[]{1, 2, 5, 7, 2, 3, 5, 8, 2, 11, 9};
    for (auto e: a) {
        us.insert(e);
    }
    for (auto e: us) {
        cout << e << " ";
    }
    cout << endl;
    cout << "========================" << endl;
    us.erase(1);
    us.erase(2);

    auto pos = us.find(11);
    us.erase(pos);
    for (auto e: us) {
        cout << e << " ";
    }
    cout << endl;
    cout << "========================" << endl;

    unordered_set<int> us1;
    us1.insert(100);
    us1.swap(us);
    cout << "us:";
    for (auto e: us) {
        cout << e << " ";
    }
    cout << endl;

    cout << "us1:";
    for (auto e: us1) {
        cout << e << " ";
    }
    cout << endl;

    cout << "========================" << endl;

    cout << us1.count(5) << endl;
    cout << us1.count(1) << endl;
    cout << "========================" << endl;

    us1.clear();
    cout << "us:";
    for (auto e: us) {
        cout << e << " ";
    }
    cout << endl;

    cout << "us1:";
    for (auto e: us1) {
        cout << e << " ";
    }
    cout << endl;

}
2.2.5、unordered_set的桶操作
函数名称接口说明
bucket_count返回unordered_set中的桶的个数
bucket_size返回第n个桶中元素的个数
bucket返回元素k在哪个桶
void test_us5() {
    unordered_set<int> us;
    int a[]{1, 2, 5, 7, 2, 3, 5, 8, 2, 11, 9};
    for (auto e: a) {
        us.insert(e);
    }

    cout << us.bucket_count() << endl;
    cout << us.bucket_size(1) << endl;
    cout << us.bucket(11) << endl;
}

3、unordered_multiset

这个其实就和set和multiset一样，就是比unordered_set多了一个可以存重复值的特性。

演示一下：

void test_ums1() {
    unordered_multiset<int> ums;
    int a[]{1, 2, 5, 7, 2, 3, 5, 8, 2, 11, 9};
    for (auto e: a) {
        ums.insert(e);
    }

    for (auto e: ums) {
        cout << e << " ";
    }
    cout << endl;
}

4、unordered_set的底层结构

unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。

4.1、哈希概念

哈希（Hash）是一种常见的数据结构和算法，用于快速地将数据映射到固定大小的索引值，通常是一个整数。哈希函数将输入数据映射到索引值，这使得可以快速地在数据结构中查找、插入或删除数据，而无需遍历整个数据结构。

哈希是一种将任意长度的输入数据通过哈希函数转换为固定长度的输出数据的过程。哈希函数将输入数据映射到一个称为哈希值或散列值的固定大小的值。哈希函数通常设计为能够尽可能均匀地将不同的输入映射到不同的输出，以减少哈希碰撞的可能性。

例如：

问题：按上述映射，插入10会出现什么问题？

答：因为10%8=2，而2的位置已经被占了，那么我们就要想办法解决这个问题。常见有两个方案：

方案一：使用开放定址法，从2的位置向后找到一个没有使用的位置插入。

方案二：使用拉链法（哈希桶），让数组每个位置存的都是一个结点的指针，当出现映射到同一个位置时，直接进行头插。

4.2、哈希冲突

哈希冲突是指两个不同的输入数据经过哈希函数计算后，得到了相同的哈希值。由于哈希函数将不同的输入映射到有限的输出空间，而输入空间是无限的，所以在实际应用中，哈希冲突是不可避免的。

解决哈希冲突的常见方法包括：

  1. 链表法（Separate Chaining）： 将具有相同哈希值的数据存储在同一个位置上，形成链表或其他数据结构。这样，当发生哈希冲突时，可以将冲突的数据连接在一起，不会丢失数据。
  2. 开放地址法（Open Addressing）： 当发生哈希冲突时，通过探测序列（如线性探测、二次探测、双重哈希等）在哈希表中寻找另一个可用的位置来存储冲突的数据。

4.3、哈希函数

哈希函数是将输入数据映射到哈希值的函数。一个好的哈希函数应该尽可能地均匀地将输入映射到输出，以减少哈希冲突的发生。哈希函数的选择取决于应用的需求和数据的特性。

常见的哈希函数的构造方法：

  1. 直接定址法（常用）：取关键字或关键字的某个线性函数值为哈希地址。即 H(key)=key 或 H(key)=a*key+b，其中a和b为常数。这种方法简单直观，但仅适用于关键字分布基本均匀的情况。若关键字的分布极不均匀，则哈希表中有的区域会很拥挤，而有的区域则可能空闲很多。
  2. 除留余数法（常用）：选取关键字除以某个整数p的余数作为哈希地址。哈希函数的一般形式为：Hash(key)=key % p。这种方法的关键在于选择合适的p，通常要求p小于等于哈希表长度m，并且接近m。
  3. 数字分析法：取关键字中某些取值较分散的数字位作为哈希地址。这种方法适合于所有关键字已知的情况，分析数字分布的情况，选择某些位作为哈希地址，尽量避免冲突。
  4. 平方取中法：取关键字平方的中间几位作为哈希地址。具体取多少位视实际要求而定。
  5. 折叠法：将关键字分割成位数相同的几段，然后将这些段叠加求和作为哈希地址。段的位数取决于哈希地址的位数，由实际需要而定。
  6. 乘法哈希法：将输入乘以一个常数，再取结果的小数部分或整数部分作为哈希值。这种方法能够在一定程度上消除冲突，并且适用于输入数据分布不均匀的情况。

4.4、解决哈希冲突

4.4.1、开放地址法（Open Addressing）

开放地址法（Open Addressing）： 当发生哈希冲突时，通过探测序列（如线性探测、二次探测、双重哈希等）在哈希表中寻找另一个可用的位置来存储冲突的数据。

以下是开放定址法的一些常见方法：

  1. 线性探测（Linear Probing）：
  • 当发生碰撞时，依次检查下一个槽位，直到找到一个空槽位。
  • 探测序列公式为：h(k,i) = (h′(k)+i) mod m其中 h′(k)初始哈希函数的值，i 是探测的步长， m 是哈希表的大小。
  • 线性探测可能会产生一系列聚集现象，导致槽位的线性排列。
  1. 二次探测（Quadratic Probing）：
  • 当发生碰撞时，通过一个二次探测序列来寻找下一个槽位。
  • 探测序列公式为：h(k,i)=(h′(k)+c1⋅i+c2⋅i^2) mod m，其中 c1 和 c2 是常数，m 是哈希表的大小。
  • 二次探测在碰撞发生后，会以二次的步长来搜索下一个空槽位，有助于减少线性探测的聚集现象。
  1. 双重哈希（Double Hashing）：
  • 使用两个哈希函数来计算探测序列的步长。
  • 探测序列公式为：h(k,i)=(h1(k)+i⋅h2(k)) mod m其中 h1(k) 和 h2(k) 是两个不同的哈希函数，m 是哈希表的大小。
  • 双重哈希通常能够更好地减少聚集现象，并且对于大部分数据集合，具有较好的性能。

这里我们就只介绍线性探测法：

就像前面我们介绍的哈希概念中，当插入10的时候发生冲突了，怎么解决？我们从位置2顺序向后找到一个空位置填入就行。

这里我们需要考虑到一个问题！元素删除：当一个元素删除过后，我们直接给他删了吗？实际上是不行的，因为如果直接删除了，也就是这个位置置空了，但是它后面位置的值又可能也是之前发生冲突探测过来的值，那么下次找这些值就找不到了！所以我们的解决办法是给数组的每个位置添加一个标志位：存在（EXIST）、删除（DELETE）、空（EMPTY）。这样就在删除的时候，只需要把这个位置的标志设置为DELETE就行，即只要这个位置标志不是EMPTY就可以继续向后探测！

因此有每个元素的结构体：

enum State {
   EMPTY,
   EXIST,
   DELETE
};

template<class K, class V>
struct HashData {
   pair<K, V> _kv;
   State _s;

   HashData(const pair<K, V> &kv = pair<K, V>()) : _kv(kv), _s(EMPTY) {}
};

哈希表：这里给了一个成员变量_n，用来记录当前哈希表中的元素个数

template<class K, class V>
class HashTable_OpenAddr {
   typedef HashData<K, V> Node;
public:

   HashTable_OpenAddr(size_t size = 10) {
       _tables.resize(size);
   }

   Node *Find(const K &key) {
       int hashi = key % _tables.size();
       while (_tables[hashi]._s == EXIST) {
           if (_tables[hashi]._kv.first == key)
               return &_tables[hashi];
           hashi++;
           hashi %= _tables.size(); // 可能从尾部到头部了
       }
       return nullptr;
   }

   bool Insert(const pair<K, V> &kv) {
       if (Find(kv.first))
           return false; // 存在就不插入了
       if (_n * 10 / _tables.size() >= 7) {
           // 装填因子为0.7，扩容
           size_t newSize = 2 * _tables.size();
//            _tables.resize(newSize);

           // 把原数据重新放到新空间中
           HashTable_OpenAddr<K, V,HashMode> newHashTable(newSize);
           for (auto &e: _tables) {
               if (e._s == EXIST) {
                   newHashTable.Insert(e._kv);
               }
           }
           _tables.swap(newHashTable._tables);
       }
      
       int hashi = kv.first % _tables.size();
       while (_tables[hashi]._s == EXIST) {
           hashi++;
           hashi %= _tables.size(); // 可能从尾部到头部了
       }
       // 现在hashi的位置是空的或者是删除了的
       _tables[hashi]._kv = kv;
       _tables[hashi]._s = EXIST;
       ++_n;
       return true;
   }

   bool Erase(const K &key) {
       Node *ret = Find(key);
       if (ret) {
           --_n;
           ret->_s = DELETE;
           return true;
       } else {
           return false;
       }
   }


private:
   vector<Node> _tables;
   size_t _n = 0;
};

这里还会有一个问题：如果我们插入的值不是int类型呢？比如string类型，那么key就是string，直接插入将会报错。

我们可以设计一个仿函数，将string类型的key映射位size_t类型的值，来用来映射位置。

// 默认的取key的用来哈希的值
template<class K>
struct HashNodeFunc {
   size_t operator()(const K &key) {
       return (size_t) key;
   }
};

//特化string类型的key的用来哈希的值
template<>
struct HashNodeFunc<string> {
   size_t operator()(const string &str) {
       size_t hash = 0;
       for (auto e: str) {
           e *= 131;
           hash += e;
       }
       return hash;
   }
};

这里string的特化函数，用的是BKDR方法（有大佬测试过这个方法取的值引起冲突的概率最小），其他的方法在这个网站字符串的Hash函数

因此我们的代码变为：

enum State {
   EMPTY,
   EXIST,
   DELETE
};

// 哈希表 --- 开放定址法
template<class K, class V>
struct HashData {
   pair<K, V> _kv;
   State _s;

   HashData(const pair<K, V> &kv = pair<K, V>()) : _kv(kv), _s(EMPTY) {}
};

template<class K>
struct HashNodeFunc {
   size_t operator()(const K &key) {
       return (size_t) key;
   }
};

template<>
struct HashNodeFunc<string> {
   size_t operator()(const string &str) {
       size_t hash = 0;
       for (auto e: str) {
           e *= 131;
           hash += e;
       }
       return hash;
   }
};


template<class K, class V, class HashMode = HashNodeFunc<K> >
class HashTable_OpenAddr {
   typedef HashData<K, V> Node;
public:

   HashTable_OpenAddr(size_t size = 10) {
       _tables.resize(size);
   }

   Node *Find(const K &key) {
       HashMode hs;
       int hashi = hs(key) % _tables.size();
       while (_tables[hashi]._s == EXIST) {
           if (_tables[hashi]._kv.first == key)
               return &_tables[hashi];
           hashi++;
           hashi %= _tables.size(); // 可能从尾部到头部了
       }
       return nullptr;
   }

   bool Insert(const pair<K, V> &kv) {
       if (Find(kv.first))
           return false; // 存在就不插入了
       
       HashMode hs;
       int hashi = hs(kv.first) % _tables.size();
       while (_tables[hashi]._s == EXIST) {
           hashi++;
           hashi %= _tables.size(); // 可能从尾部到头部了
       }
       // 现在hashi的位置是空的或者是删除了的
       _tables[hashi]._kv = kv;
       _tables[hashi]._s = EXIST;
       ++_n;
       return true;
   }

   bool Erase(const K &key) {
       Node *ret = Find(key);
       if (ret) {
           --_n;
           ret->_s = DELETE;
           return true;
       } else {
           return false;
       }
   }


private:
   vector<Node> _tables;
   size_t _n = 0;
};

如果我们需要插入自定义类型，比如Date类型的元素，我们可以自己写一个哈希函数来传入模版参数。

如下，包含测试：

class Date {
public:
   Date(int year = 1999, int month = 11, int day = 14) : _year(year), _month(month), _day(day) {

   }

   int getYear() const {
       return _year;
   }

   int getMonth() const {
       return _month;
   }

   int getDay() const {
       return _day;
   }

   bool operator==(const Date& d) {
       return _year == d._year && _month == d._month && _day == d._day;
   }

private:
   int _year;
   int _month;
   int _day;
};

struct HashNodeDate{
   size_t operator()(const Date &d) {
       size_t hash = 0;
       hash += d.getYear() * 131;
       hash += d.getMonth() * 131;
       hash += d.getDay() * 131;
       return hash;
   }
};

void test_Hash_Table4() {
   Date *d[] = {new Date(), new Date(1998, 1, 1), new Date(2000, 12, 11)};
   HashTable_OpenAddr<Date, Date, HashNodeDate> hs;
   for (auto e: d) {
       hs.Insert(make_pair(*e, *e));
   }
   hs.Erase(*new Date(1998, 1, 1));
}

当哈希表什么时候进行扩容？怎么扩容？

这里涉及到一个概念：装填因子。

装填因子 = 存入哈希表的元素个数/哈希表长。

对于开放定址法，装填因子是一个特别重要的元素，应该严格控制在0.7～0.8之间。

所以我们这里在装填因子为0.7的时候进行扩容，2倍扩容。

扩容方式是遍历旧表，状态为EXIST的元素插入到新表，按新表的映射方式进行插入。

代码如下：

if (_n * 10 / _tables.size() >= 7) {
           // 装填因子为0.7，扩容
           size_t newSize = 2 * _tables.size();
//            _tables.resize(newSize);

           // 把原数据重新放到新空间中
           HashTable_OpenAddr<K, V,HashMode> newHashTable(newSize);
           for (auto &e: _tables) {
               if (e._s == EXIST) {
                   newHashTable.Insert(e._kv);
               }
           }
           _tables.swap(newHashTable._tables);
}

因此开放定址法的哈希表的整体代码为：

enum State {
   EMPTY,
   EXIST,
   DELETE
};

// 哈希表 --- 开放定址法
template<class K, class V>
struct HashData {
   pair<K, V> _kv;
   State _s;

   HashData(const pair<K, V> &kv = pair<K, V>()) : _kv(kv), _s(EMPTY) {}
};

template<class K>
struct HashNodeFunc {
   size_t operator()(const K &key) {
       return (size_t) key;
   }
};

template<>
struct HashNodeFunc<string> {
   size_t operator()(const string &str) {
       size_t hash = 0;
       for (auto e: str) {
           e *= 131;
           hash += e;
       }
       return hash;
   }
};


template<class K, class V, class HashMode = HashNodeFunc<K> >
class HashTable_OpenAddr {
   typedef HashData<K, V> Node;
public:

   HashTable_OpenAddr(size_t size = 10) {
       _tables.resize(size);
   }

   Node *Find(const K &key) {
       HashMode hs;
       int hashi = hs(key) % _tables.size();
       while (_tables[hashi]._s == EXIST) {
           if (_tables[hashi]._kv.first == key)
               return &_tables[hashi];
           hashi++;
           hashi %= _tables.size(); // 可能从尾部到头部了
       }
       return nullptr;
   }

   bool Insert(const pair<K, V> &kv) {
       if (Find(kv.first))
           return false; // 存在就不插入了
       if (_n * 10 / _tables.size() >= 7) {
           // 装填因子为0.7，扩容
           size_t newSize = 2 * _tables.size();
//            _tables.resize(newSize);

           // 把原数据重新放到新空间中
           HashTable_OpenAddr<K, V,HashMode> newHashTable(newSize);
           for (auto &e: _tables) {
               if (e._s == EXIST) {
                   newHashTable.Insert(e._kv);
               }
           }
           _tables.swap(newHashTable._tables);
       }
       HashMode hs;
       int hashi = hs(kv.first) % _tables.size();
       while (_tables[hashi]._s == EXIST) {
           hashi++;
           hashi %= _tables.size(); // 可能从尾部到头部了
       }
       // 现在hashi的位置是空的或者是删除了的
       _tables[hashi]._kv = kv;
       _tables[hashi]._s = EXIST;
       ++_n;
       return true;
   }

   bool Erase(const K &key) {
       Node *ret = Find(key);
       if (ret) {
           --_n;
           ret->_s = DELETE;
           return true;
       } else {
           return false;
       }
   }


private:
   vector<Node> _tables;
   size_t _n = 0;
};
4.4.2、链表法（Separate Chaining）

链表法（Separate Chaining）： 将具有相同哈希值的数据存储在同一个位置上，形成链表或其他数据结构。这样，当发生哈希冲突时，可以将冲突的数据连接在一起，不会丢失数据。

这里我们数组中存的元素必然是一个指针！如果偷懒的话，其实可以在vector中存一个list，即vector<list<pair<K,V>>> _tables。但是我们秉承着低耦合和高内聚的理念，我们还是自己写一个结构体用来存每个结点的数据。

存结点数据的结构体：

template<class K, class V>
struct HashNode {
    typedef HashNode<K, V> Node;

    Node *_next;
    pair<K, V> _kv;

    HashNode(const pair<K, V> &kv) : _kv(kv), _next(nullptr) {}

};

**哈希表：**仿函数还是要写的，和开放定址法一样！

template<class K, class V, class Hash = HashFunc<K>>
class HashTable {
    typedef HashNode<K, V> Node;
public:
  
    HashTable(size_t size = 10) {
        _tables.resize(size, nullptr);// 各结点初始化为空
    }

    Node *Find(const K &key) {
        Hash hs;
        // 先算出映射到哪里
        int hashi = hs(key) % _tables.size();
        Node *cur = _tables[hashi];
        while (cur) {
            if (cur->_kv.first == key) {
                return cur;
            }
            cur = cur->_next;
        }
        return nullptr; // 没找到
    }

    bool Erase(const K &key) {
        Hash hs;
        Node *ret = Find(key);
        if (ret) {
            int hashi = hs(key) % _tables.size();
            Node *cur = _tables[hashi];
            Node *prev = nullptr;
            while (cur) {
                if (cur->_kv.first == key) {
                    if (prev == nullptr)
                        _tables[hashi] = cur->_next; // 要删除的就是表中的结点，那么将它的下一个结点放到表中
                    else
                        prev->_next = cur->_next; // 要删除的是表中的结点的后继中的某个

                    delete cur; // 删除该结点并退出循环
                    break;
                }
                prev = cur;
                cur = cur->_next;
            }
            --_n;
            return true;
        } else {
            return false;
        }
    }

    bool Insert(const pair<K, V> &kv) {

        Hash hs;
        if (Find(kv.first))
            return false;// 找到了

        // 先算出映射到哪里
        int hashi = hs(kv.first) % _tables.size();
        Node *cur = _tables[hashi];
        Node *newnode = new Node(kv);
        if (cur) {
            // 当前表中的结点不为空，则头插并链接
            newnode->_next = cur;
            _tables[hashi] = newnode;
        } else {
            // 当前表中的结点为空，则新结点直接放到这个表中
            _tables[hashi] = newnode;
        }
        ++_n;
        return true;
    }

private:
    vector<Node *> _tables;
    size_t _n = 0;
};

考虑一下哈希表的扩容？考虑极端情况下，也就是很多元素进行插入，但是我们这里初始的哈希表的长度为10，那么插入很多元素后会导致每个位置（我们这里叫桶）的结点下面的链表的长度很长，下次查找的时候需要遍历链表，很花时间！

官方的扩容条件是在装填因子为1的时候进行扩容！

那么这里是怎么进行扩容呢？

我们可以直接遍历旧表，将旧表的元素按新表的映射方式全部插入到新表中，并把旧表释放。

if (_n == _tables.size()) {
            // 扩容
            vector<Node *> newTables;
            newTables.resize(2 * _tables.size(), nullptr);
            for (int i = 0; i < _tables.size(); ++i) {
                Node *cur = _tables[i];
                while (cur) {
                    Node *next = cur->_next; //记录下一个结点位置，防止找不到下一个结点
                    // 映射到新表位置
                    int hashi = hs(cur->_kv.first) % newTables.size();
                    // 插入到新表位置
                    Node *newcur = newTables[hashi];
                    if (newcur) {
                        // 当前表中的结点不为空，则头插并链接
                        cur->_next = newcur;
                        newTables[hashi] = cur;
                    } else {
                        // 当前表中的结点为空，则新结点直接放到这个表中
                        newTables[hashi] = cur;
                        cur->_next = nullptr;// 新插入的cur的_next不一定是空
                    }
                    cur = next;// 继续往下找
                }
            }
            _tables.swap(newTables);
}

因此链表法哈希表的整体代码为：

// 哈希表 --- 拉链法/哈希桶
template<class K, class V>
struct HashNode {
    typedef HashNode<K, V> Node;

    Node *_next;
    pair<K, V> _kv;

    HashNode(const pair<K, V> &kv) : _kv(kv), _next(nullptr) {}

};

template<class K>
struct HashFunc {
    size_t operator()(const K &key) {
        return (size_t) key;
    }
};

template<>
struct HashFunc<string> {
    size_t operator()(const string &str) {
        size_t hash = 0;
        for (auto e: str) {
            hash += e;
            e *= 131;
        }
        return hash;
    }
};

template<class K, class V, class Hash = HashFunc<K>>
class HashTable {
    typedef HashNode<K, V> Node;
public:
    ~HashTable() {
        for (int i = 0; i < _tables.size(); ++i) {
            _tables[i] = nullptr;
        }
    }

    HashTable(size_t size = 10) {
        _tables.resize(size, nullptr);// 各结点初始化为空
    }

    Node *Find(const K &key) {
        Hash hs;
        // 先算出映射到哪里
        int hashi = hs(key) % _tables.size();
        Node *cur = _tables[hashi];
        while (cur) {
            if (cur->_kv.first == key) {
                return cur;
            }
            cur = cur->_next;
        }
        return nullptr; // 没找到
    }

    bool Erase(const K &key) {
        Hash hs;
        Node *ret = Find(key);
        if (ret) {
            int hashi = hs(key) % _tables.size();
            Node *cur = _tables[hashi];
            Node *prev = nullptr;
            while (cur) {
                if (cur->_kv.first == key) {
                    if (prev == nullptr)
                        _tables[hashi] = cur->_next; // 要删除的就是表中的结点，那么将它的下一个结点放到表中
                    else
                        prev->_next = cur->_next; // 要删除的是表中的结点的后继中的某个

                    delete cur; // 删除该结点并退出循环
                    break;
                }
                prev = cur;
                cur = cur->_next;
            }
            --_n;
            return true;
        } else {
            return false;
        }
    }

    bool Insert(const pair<K, V> &kv) {

        Hash hs;
        if (Find(kv.first))
            return false;// 找到了
        if (_n == _tables.size()) {
            // 扩容
            vector<Node *> newTables;
            newTables.resize(2 * _tables.size(), nullptr);
            for (int i = 0; i < _tables.size(); ++i) {
                Node *cur = _tables[i];
                while (cur) {
                    Node *next = cur->_next; //记录下一个结点位置，防止找不到下一个结点
                    // 映射到新表位置
                    int hashi = hs(cur->_kv.first) % newTables.size();
                    // 插入到新表位置
                    Node *newcur = newTables[hashi];
                    if (newcur) {
                        // 当前表中的结点不为空，则头插并链接
                        cur->_next = newcur;
                        newTables[hashi] = cur;
                    } else {
                        // 当前表中的结点为空，则新结点直接放到这个表中
                        newTables[hashi] = cur;
                        cur->_next = nullptr;// 新插入的cur的_next不一定是空
                    }
                    cur = next;// 继续往下找
                }
            }
            _tables.swap(newTables);
        }

        // 先算出映射到哪里
        int hashi = hs(kv.first) % _tables.size();
        Node *cur = _tables[hashi];
        Node *newnode = new Node(kv);
        if (cur) {
            // 当前表中的结点不为空，则头插并链接
            newnode->_next = cur;
            _tables[hashi] = newnode;
        } else {
            // 当前表中的结点为空，则新结点直接放到这个表中
            _tables[hashi] = newnode;
        }
        ++_n;
        return true;
    }

private:
    vector<Node *> _tables;
    size_t _n = 0;
};

我们开放定址法和链表法用的扩容都是两倍扩容，但是官方用的是使用素数扩容，也就是每次扩容后哈希表的长度都是素数，据说这样会让元素更加分散。但其实并没有哈哈哈，Java底层就是2倍扩容。那么怎么做到差不多2倍扩容，每次扩容后哈希表长度都是素数呢？

size_t GetNextPrime(size_t prime) {
    const int PRIMECOUNT = 28;
    static const size_t primeList[PRIMECOUNT] =
            {
                    53ul, 97ul, 193ul, 389ul, 769ul,
                    1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
                    49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
                    1572869ul, 3145739ul, 6291469ul, 12582917ul,
                    25165843ul,
                    50331653ul, 100663319ul, 201326611ul, 402653189ul,
                    805306457ul,
                    1610612741ul, 3221225473ul, 4294967291ul
            };
    size_t i = 0;
    for (; i < PRIMECOUNT; ++i) {
        if (primeList[i] > prime)
            return primeList[i];
    }

    return primeList[i];
}

5、unordered_set的模拟实现

以下我们自己模拟实现的时候，unordered_set的模拟实现我们使用MyUnordered_Set类用于区分，unordered_map的模拟实现我们使用MyUnordered_Map类用于区分。

5.1、改造哈希表（链表法）

结点的结构体需要修改一下，之前我们存的是pair<K,V>，但MyUnordered_Set是存K的，因此我们模版参数设置为一个参数T，MyUnordered_Set调用就是K，MyUnordered_Map调用就是pair<K,V>。

template<class T>
struct HashNode {
    typedef HashNode<T> Node;

    Node *_next;
    T _data;

    HashNode(const T &data) : _data(data), _next(nullptr) {}

};

哈希表需要增加一个模版参数：取Key的仿函数，因为MyUnordered_Set插入的是K，但是MyUnordered_Map插入的是pair<K,V>，我们需要从pair<K,V>中取出K。因此插入也要改成bool Insert(const T &data){}

这个仿函数分别放在MyUnordered_Set和MyUnordered_Map的类中，用来传给哈希表。

MyUnordered_Set类中：

struct MapKeyOfT {
        K operator()(const pair<K, V> &kv) {
            return kv.first;
        }
};

MyUnordered_Map类中：

struct MapKeyOfT {
        K operator()(const pair<K, V> &kv) {
            return kv.first;
        }
 };

因此当前改造后的哈希表为：

template<class T>
struct HashNode {
    typedef HashNode<T> Node;

    Node *_next;
    T _data;

    HashNode(const T &data) : _data(data), _next(nullptr) {}

};

template<class K>
struct HashFunc {
    size_t operator()(const K &key) {
        return (size_t) key;
    }
};

template<>
struct HashFunc<string> {
    size_t operator()(const string &str) {
        size_t hash = 0;
        for (auto e: str) {
            hash += e;
            e *= 131;
        }
        return hash;
    }
};

template<class K, class T, class KeyOfT, class Hash>
class HashTable {
    typedef HashNode<T> Node;
public:
    
    ~HashTable() {
        for (int i = 0; i < _tables.size(); ++i) {
            _tables[i] = nullptr;
        }
    }

    HashTable(size_t size = 10) {
        _tables.resize(size, nullptr);// 各结点初始化为空
    }

    Node* Find(const K &key) {
        Hash hs;
        KeyOfT kot;
        // 先算出映射到哪里
        int hashi = hs(key) % _tables.size();
        Node *cur = _tables[hashi];
        while (cur) {
            if (kot(cur->_data) == key) {
                return cur;
            }
            cur = cur->_next;
        }
        return nullptr; // 没找到
    }

    bool Erase(const K &key) {
        Hash hs;
        KeyOfT kot;
        iterator ret = Find(key);
        if (ret != end()) {
            int hashi = hs(key) % _tables.size();
            Node *cur = _tables[hashi];
            Node *prev = nullptr;
            while (cur) {
                if (kot(cur->_data) == key) {
                    if (prev == nullptr)
                        _tables[hashi] = cur->_next; // 要删除的就是表中的结点，那么将它的下一个结点放到表中
                    else
                        prev->_next = cur->_next; // 要删除的是表中的结点的后继中的某个

                    delete cur; // 删除该结点并退出循环
                    break;
                }
                prev = cur;
                cur = cur->_next;
            }
            --_n;
            return true;
        } else {
            return false;
        }
    }

    bool Insert(const T &data) {

        Hash hs;
        KeyOfT kot;
        if (Find(kot(data)))
            return false;// 找到了
        if (_n == _tables.size()) {
            // 扩容
            vector<Node *> newTables;
            newTables.resize(2 * _tables.size(), nullptr);
            for (int i = 0; i < _tables.size(); ++i) {
                Node *cur = _tables[i];
                while (cur) {
                    Node *next = cur->_next; //记录下一个结点位置，防止找不到下一个结点
                    // 映射到新表位置
                    int hashi = hs(kot(cur->_data)) % newTables.size();
                    // 插入到新表位置
                    Node *newcur = newTables[hashi];
                    if (newcur) {
                        // 当前表中的结点不为空，则头插并链接
                        cur->_next = newcur;
                        newTables[hashi] = cur;
                    } else {
                        // 当前表中的结点为空，则新结点直接放到这个表中
                        newTables[hashi] = cur;
                        cur->_next = nullptr;// 新插入的cur的_next不一定是空
                    }
                    cur = next;// 继续往下找
                }
            }
            _tables.swap(newTables);
        }

        // 先算出映射到哪里
        int hashi = hs(kot(data)) % _tables.size();
        Node *cur = _tables[hashi];
        Node *newnode = new Node(data);
        if (cur) {
            // 当前表中的结点不为空，则头插并链接
            newnode->_next = cur;
            _tables[hashi] = newnode;
        } else {
            // 当前表中的结点为空，则新结点直接放到这个表中
            _tables[hashi] = newnode;
        }
        ++_n;
        return true;
    }

private:
    vector<Node *> _tables;
    size_t _n = 0;
};

还需要增加迭代器，用来遍历哈希表。

// 前置声明
template<class K, class T, class KeyOfT, class Hash>
class HashTable;

template<class K, class T, class KeyOfT, class Hash>
struct __HTIterator {

    typedef HashNode<T> Node;
    typedef HashTable<K, T, KeyOfT, Hash> HT;
    typedef __HTIterator<K, T, KeyOfT, Hash> Self;

    Node *_node;
    HT *_ht;

    __HTIterator(Node *node, HT *ht) : _node(node), _ht(ht) {}


    T &operator*() {
        return _node->_data;
    }

    T *operator->() {
        return &_node->_data;
    }

    Self &operator++() {
        if (_node->_next) {
            // 当前结点还有后继结点
            _node = _node->_next;
        } else {
            // 当前桶走完了
            KeyOfT kot;
            Hash hs;

            // 先算出当前在哪个哈希桶
            int hashi = hs(kot(_node->_data)) % _ht->_tables.size();
            ++hashi;// 走到下一个桶

            while (hashi < _ht->_tables.size()) {
                if (_ht->_tables[hashi]) {
                    //  这个桶有结点
                    _node = _ht->_tables[hashi];
                    break;
                } else
                    ++hashi;// 这个桶没有有结点
            }

            if (hashi == _ht->_tables.size()) {
                // 走到最后了，没找到下一个位置
                _node = nullptr;
            }

        }
        return *this;
    }

    bool operator!=(const Self &s) {
        return s._node != _node;
    }
};

改造后的哈希表（终极版）：这里的插入的返回值由bool变为了pair<iterator,bool>，和官方保持一致。

template<class T>
struct HashNode {
    typedef HashNode<T> Node;

    Node *_next;
    T _data;

    HashNode(const T &data) : _data(data), _next(nullptr) {}

};

template<class K>
struct HashFunc {
    size_t operator()(const K &key) {
        return (size_t) key;
    }
};

template<>
struct HashFunc<string> {
    size_t operator()(const string &str) {
        size_t hash = 0;
        for (auto e: str) {
            hash += e;
            e *= 131;
        }
        return hash;
    }
};


// 前置声明
template<class K, class T, class KeyOfT, class Hash>
class HashTable;

template<class K, class T, class KeyOfT, class Hash>
struct __HTIterator {

    typedef HashNode<T> Node;
    typedef HashTable<K, T, KeyOfT, Hash> HT;
    typedef __HTIterator<K, T, KeyOfT, Hash> Self;

    Node *_node;
    HT *_ht;

    __HTIterator(Node *node, HT *ht) : _node(node), _ht(ht) {}


    T &operator*() {
        return _node->_data;
    }

    T *operator->() {
        return &_node->_data;
    }

    Self &operator++() {
        if (_node->_next) {
            // 当前结点还有后继结点
            _node = _node->_next;
        } else {
            // 当前桶走完了
            KeyOfT kot;
            Hash hs;

            // 先算出当前在哪个哈希桶
            int hashi = hs(kot(_node->_data)) % _ht->_tables.size();
            ++hashi;// 走到下一个桶

            while (hashi < _ht->_tables.size()) {
                if (_ht->_tables[hashi]) {
                    //  这个桶有结点
                    _node = _ht->_tables[hashi];
                    break;
                } else
                    ++hashi;// 这个桶没有有结点
            }

            if (hashi == _ht->_tables.size()) {
                // 走到最后了，没找到下一个位置
                _node = nullptr;
            }

        }
        return *this;
    }

    bool operator!=(const Self &s) {
        return s._node != _node;
    }
};

template<class K, class T, class KeyOfT, class Hash>
class HashTable {
    friend __HTIterator<K, T, KeyOfT, Hash>;// 为了能访问_tables
    typedef HashNode<T> Node;
public:

    typedef __HTIterator<K, T, KeyOfT, Hash> iterator;

    iterator begin() {
        for (int i = 0; i < _tables.size(); ++i) {
            if (_tables[i])
                return iterator(_tables[i], this);// 从左找到第一个哈希桶的第一个结点
        }
        return end();
    }

    iterator end() {
        return iterator(nullptr, this);
    }

    ~HashTable() {
        for (int i = 0; i < _tables.size(); ++i) {
            _tables[i] = nullptr;
        }
    }

    HashTable(size_t size = 10) {
        _tables.resize(size, nullptr);// 各结点初始化为空
    }

    iterator Find(const K &key) {
        Hash hs;
        KeyOfT kot;
        // 先算出映射到哪里
        int hashi = hs(key) % _tables.size();
        Node *cur = _tables[hashi];
        while (cur) {
            if (kot(cur->_data) == key) {
                return iterator(cur, this);
            }
            cur = cur->_next;
        }
        return iterator(nullptr, this); // 没找到
    }

    bool Erase(const K &key) {
        Hash hs;
        KeyOfT kot;
        iterator ret = Find(key);
        if (ret != end()) {
            int hashi = hs(key) % _tables.size();
            Node *cur = _tables[hashi];
            Node *prev = nullptr;
            while (cur) {
                if (kot(cur->_data) == key) {
                    if (prev == nullptr)
                        _tables[hashi] = cur->_next; // 要删除的就是表中的结点，那么将它的下一个结点放到表中
                    else
                        prev->_next = cur->_next; // 要删除的是表中的结点的后继中的某个

                    delete cur; // 删除该结点并退出循环
                    break;
                }
                prev = cur;
                cur = cur->_next;
            }
            --_n;
            return true;
        } else {
            return false;
        }
    }

    pair<iterator, bool> Insert(const T &data) {

        Hash hs;
        KeyOfT kot;
        iterator it = Find(kot(data));
        if (it != end())
            return make_pair(it, false);// 找到了
        if (_n == _tables.size()) {
            // 扩容
            vector<Node *> newTables;
            newTables.resize(2 * _tables.size(), nullptr);
            for (int i = 0; i < _tables.size(); ++i) {
                Node *cur = _tables[i];
                while (cur) {
                    Node *next = cur->_next; //记录下一个结点位置，防止找不到下一个结点
                    // 映射到新表位置
                    int hashi = hs(kot(cur->_data)) % newTables.size();
                    // 插入到新表位置
                    Node *newcur = newTables[hashi];
                    if (newcur) {
                        // 当前表中的结点不为空，则头插并链接
                        cur->_next = newcur;
                        newTables[hashi] = cur;
                    } else {
                        // 当前表中的结点为空，则新结点直接放到这个表中
                        newTables[hashi] = cur;
                        cur->_next = nullptr;// 新插入的cur的_next不一定是空
                    }
                    cur = next;// 继续往下找
                }
            }
            _tables.swap(newTables);
        }

        // 先算出映射到哪里
        int hashi = hs(kot(data)) % _tables.size();
        Node *cur = _tables[hashi];
        Node *newnode = new Node(data);
        if (cur) {
            // 当前表中的结点不为空，则头插并链接
            newnode->_next = cur;
            _tables[hashi] = newnode;
        } else {
            // 当前表中的结点为空，则新结点直接放到这个表中
            _tables[hashi] = newnode;
        }
        ++_n;
        return make_pair(iterator(_tables[hashi], this), true);
    }

private:
    vector<Node *> _tables;
    size_t _n = 0;
};

5.2、MyUnordered_Set类的构成

其实就是套了一层哈希表，多了一个SetKeyOfT用来传给哈希表的模版参数。

#include "HashTable_Bucket.h"

template<class K, class Hash = HashFunc<K>>
class MyUnordered_Set {
    struct SetKeyOfT {
        K operator()(const K &key) {
            return key;
        }
    };

public:

    typedef typename HashTable<K, const K, SetKeyOfT, Hash>::iterator iterator;

    iterator begin() {
        return _hs.begin();
    }

    iterator end() {
        return _hs.end();
    }

    pair<iterator,bool> insert(const K &key) {
        return _hs.Insert(key);
    }

    bool erase(const K &key) {
        return _hs.Erase(key);
    }

    iterator find(const K &key) {
        return _hs.Find(key);
    }



private:
    HashTable<K, const K, SetKeyOfT, Hash> _hs;
};

OKOK，C++ STL容器之unordered_set类就到这里。如果你对Linux和C++也感兴趣的话，可以看看我的主页哦。下面是我的github主页，里面记录了我的学习代码和leetcode的一些题的题解，有兴趣的可以看看。

Xpccccc的github主页

Xpccccc
关注
  • 41
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
STL容器之unordered_map类
Xpccccc的博客
04-09 584
STL容器之unordered_map类
STL容器——unordered_set的用法
嵌入式点灯砖家的博客
06-19 3815
容器，可直译为无序 set 容器。即容器和set容器很像，唯一的区别就在于set容器会自行对存储的数据进行排序，而容器不会。下面是setmultiset和之间的差别。注意这三种集合的底层实现，他决定了算法的时间复杂度。特别注意multiset其实是数值可重复版本的set。需要添加头文件和命名空间# include using namespace std;
STL无序容器之unordered_set和unordered_multiset
AndyJ的学习之旅
05-07 1605
参考链接 unordered_set unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会。 unordered_set 容器具有以下几个特性： 不再以键值对的形式存储数据，而是直接存储数据的值； 容器内部存储的各个元素的值都互不相等，且不能被修改。 不会对内部存储的数据进行排序（这和该容器底层采用哈希表结构存储数据有关） 实现 unordered_set 容器的模板类定义在<unordered_s
C++ STL 的【unordered_set】容器
m0_51913750的博客
12-27 187
C++ STL 的 unordered_set 容器
STL关联式容器：unordered_map和unordered_set
Outtch_的博客
09-03 757
前言 在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(logN)，即最差情况下需要比较红黑树的高度次，当树中的结点非常多时，查询效率也不理想。 在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map和unordered_set进行介绍。 一：unordered_map和unordered_set unordered_map/unordered_s
STL容器系列文章：unordered_set容器
shuaixio的博客
06-21 565
STL，unordered_set容器，无序集合，hashTable存储
STL总结之unordered_set/unordered_multiset
YangLei253的博客
07-29 1161
介绍 unordered_set 是一个封装哈希表的无序容器，其中每个元素仅可出现一次。 unordered_multiset 是一个封装哈希表的无序容器，其中每个元素可出现任意次。 unordered_set 和 unordered_multiset 均定义于头文件 <unordered_set> 中，各自声明如下： template< class Key, c...
STL容器之＜unordered_set＞
沉默、凝视的博客
04-05 582
关联式容器。元素是唯一的，既是值又是键。元素不能直接修改，需要先删除再插入。支持单向迭代器。插入元素时不会使迭代器失效，删除元素时会使指向已删除元素的迭代器失效。插入、删除和查找元素时间复杂度为O(1)，最坏情况下为O(n)。。_Value：表示存储的数据类型_Hash：哈希函数对象类型_Pred：表示按照键的排序方式。_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。
【C++】-- STL之unordered_map/unordered_set详解
局部变量和全局变量
09-13 2272
STL有两种容器:序列式容器和关联式容器，序列式容器vetor/lost/deque，用来存储数据。关联式容器map/set/unordered_map/unordered_set用来存储数据+查找数据。 unordered_map和unordered_set是c++里面两个提供哈希表的容器，map和set底层是红黑树，unordered_map和unordered_set的底层是哈希表（散列表），是一种映射。
细讲c++ 各种STL容器的应用场合及性能
04-01
c++ std stl各容器的应用场合及性能 map hash_map unordered_map multimap list forward_list vector set hash_set multiset unsorted_set queue deque priority_queue
MyStl:自己实现STL
04-30
无序关联容器：unordered_set，unordered_map，unordered_multiset，unordered_multimap 容器均支持列表初始化，重载了相关迭代器的bool类型转换运算符以支持用于条件判断 常用算法 常用仿函数 未实现 容器：forward...
tinySTL:实现了部分STL组件，又进行了部分扩充
05-14
tinySTL完成进度：STL基本组件内存相关空间配置器迭代器相关iterator，常见的五种迭代器类型(input, output, forward, bidirectional, random)reverse_iterator，用于容器的rbegin()/rend()操作iterator_traits，...
bourne:Bourne 是一个轻量级的 JSON 解串器 (C++11)
06-02
一流的对象和大多数 STL 容器是自动序列化的 (SFINAE)。 Bourne 是跨平台的。 在 Windows/Linux/MacosX 上构建。 在 g++/clang/msvc 上编译。 Bourne 很小，自包含，只有标题。 Bourne 已获得 zlib/libpng 许可。...
ctl:C模板库
03-16
CTL旨在通过在ISO C99 / C11中实现以下STL容器来提高ISO C99 / C11开发人员的生产率： deq.h = std::deque lst.h = std::list pqu.h = std::priority_queue que.h = std::queue set.h = std::set stk.h = std::...
C++：round函数用法
Solititude的博客
05-28 341
C++：round函数用法
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 817
string类各函数接口。
【如何在Qt C++中使用SSL和TLS加密传输数据？】
最新发布
m0_45463480的博客
05-28 196
在这个示例中，我们创建了一个简单的Qt应用程序，向指定的HTTPS地址发送请求，并显示响应。信号来处理响应数据。您可以从响应中读取数据并进行进一步处理。来配置SSL/TLS连接，包括对证书进行验证和加密要求等。为您要访问的实际URL，并根据需要进一步配置SSL策略。在发送请求之前，可设置SSL配置。确保您的Qt项目已经链接了网络模块（对象发送网络请求，并接收响应。对象指定要访问的URL。
STL中unordered_map和map的区别和应用场景，set、unordered_set
10-22
STL中的map和unordered_map都是关联式容器，用于存储键值对。其中，map是基于红黑树实现的有序容器，而unordered_map则是基于哈希表实现的无序容器。因此，它们的主要区别在于底层数据结构的不同，以及是否有序。 在使用时，如果需要按照键的顺序进行遍历或查找，应该使用map；如果不需要有序，而是需要快速的查找、插入和删除操作，应该使用unordered_map。 set和unordered_set也是关联式容器，用于存储元素的集合。set是基于红黑树实现的有序容器，而unordered_set则是基于哈希表实现的无序容器。同样，如果需要有序的集合，应该使用set；如果不需要有序，而是需要快速的查找、插入和删除操作，应该使用unordered_set。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Xpccccc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值