目录

一. unordered系列关联式容器

1、文档说明

2、接口说明

1. 构造

2. 容量

3. 迭代器

4. 元素访问

5. 查询

6. 修改

7. 桶操作

8. 测试

二、unordered_set

1、​​​​​​​文档说明 

2、接口说明

1. 构造

2. 容量

3. 迭代器

4. 元素访问

5. 插入和删除操作

6. 桶操作

7. 哈希策略

8. 测试 

---

一. unordered系列关联式容器

1、文档说明

• unordered_map是存储<key, value>键值对的关联式容器，其允许通过key快速的索引到与其对应的value。
• 在unordered_map中，键值通常用于唯一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
• 在内部,unordered_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内 找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
• 与map相比，unordered_map在通过key访问单个元素时更快，但在遍历元素子集的范围迭代方面效率较低。
• unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问 value。
• 它的迭代器至少是前向迭代器。

2、接口说明

1. 构造

函数声明	功能介绍
size_t bucket_count()const	返回哈希桶中桶的总个数
size_t bucket_size(size_t n)const	返回n号桶中有效元素的总个数
size_t bucket(const K& key)	返回元素key所在的桶号

8. 测试

#include <iostream>
#include <unordered_map>

int main() {
    // 构造unordered_map对象
    std::unordered_map<int, std::string> myMap = { {1, "apple"}, {2, "banana"}, {3, "orange"} };

    // 容量操作
    bool isEmpty = myMap.empty();
    size_t size = myMap.size();

    std::cout << "Is empty? " << (isEmpty ? "Yes" : "No") << std::endl;
    std::cout << "Size: " << size << std::endl;

    // 迭代器操作
    auto it = myMap.begin();
    while (it != myMap.end()) {
        std::cout << "Key: " << it->first << ", Value: " << it->second << std::endl;
        ++it;
    }

    // 元素访问
    std::string value = myMap[2];
    std::cout << "Value at key 2: " << value << std::endl;

    // 查询操作
    auto findIt = myMap.find(3);
    if (findIt != myMap.end()) {
        std::cout << "Key 3 found. Value: " << findIt->second << std::endl;
    }

    size_t count = myMap.count(1);
    std::cout << "Number of elements with key 1: " << count << std::endl;

    // 修改操作
    myMap.insert({ 4, "grape" });
    myMap.erase(1);

    // 桶操作
    size_t bucketCount = myMap.bucket_count();
    size_t bucketSize = myMap.bucket_size(2);
    size_t keyBucket = myMap.bucket(3);

    std::cout << "Bucket count: " << bucketCount << std::endl;
    std::cout << "Bucket size at index 2: " << bucketSize << std::endl;
    std::cout << "Bucket of key 3: " << keyBucket << std::endl;

    return 0;
}

二、unordered_set

1、文档说明 

• 无序集合unordered是存储没有特定顺序的唯一元素的容器，它允许基于它们的值快速检索单个元素。
• 在unordered_set中，元素的值同时也是唯一标识它的键。键是不可变的，因此，在容器中不能修改unordered_set中的元素——但是可以插入和删除它们。
• 在内部，unordered_set中的元素没有按照任何特定的顺序排序，而是根据它们的散列值组织到bucket中，以便通过它们的值直接快速访问单个元素(平均时间复杂度为常数)。
• Unordered_set容器在按键访问单个元素时比set容器快，尽管它们在通过其元素子集进行范围迭代时通常效率较低。

2、接口说明

1. 构造

函数声明	功能介绍
unordered_set	构造不同格式的unordered_set对象

2. 容量

函数声明	功能介绍
bool empty() const	检测unordered_set是否为空
size_t size() const	获取unordered_set的有效元素个数

3. 迭代器

函数声明	功能介绍
begin	返回unordered_set第一个元素的迭代器
end	返回unordered_set最后一个元素下一个位置的迭代器
cbegin	返回unordered_set第一个元素的const迭代器
cend	返回unordered_set最后一个元素下一个位置的const迭代器

4. 元素访问

函数声明	功能介绍
iterator find(const T& value)	返回值为value的元素的迭代器
size_t count(const T& value)	返回值为value的元素在unordered_set中的个数

5. 插入和删除操作

函数声明	功能介绍
pair<iterator, bool> insert(const T& value)	向容器中插入元素value
iterator erase(iterator position)	删除迭代器position指向的元素
size_type erase(const T& value)	删除值为value的元素的个数
void clear()	清空容器中的所有元素

6. 桶操作

函数声明	功能介绍
size_t bucket_count() const	返回unordered_set中桶的总个数
size_t bucket_size(size_t n) const	返回第n个桶中的元素个数
size_t bucket(const T& value) const	返回元素value所在的桶号

7. 哈希策略

函数声明	功能介绍
float load_factor() const	返回当前的负载因子
float max_load_factor() const	返回最大负载因子
void rehash(size_type count)	重新分配内部存储空间，使桶的数量至少为count
void reserve(size_type count)	设置容器的最小桶数，以容纳count个元素

8. 测试 

#include <iostream>
#include <unordered_set>

int main() {
    // 构造unordered_set对象
    std::unordered_set<int> mySet = { 1, 2, 3, 4, 5 };

    // 容量操作
    bool isEmpty = mySet.empty();
    size_t size = mySet.size();

    std::cout << "Is empty? " << (isEmpty ? "Yes" : "No") << std::endl;
    std::cout << "Size: " << size << std::endl;

    // 迭代器操作
    auto it = mySet.begin();
    while (it != mySet.end()) {
        std::cout << "Value: " << *it << std::endl;
        ++it;
    }

    // 元素访问
    auto findIt = mySet.find(3);
    if (findIt != mySet.end()) {
        std::cout << "Value 3 found." << std::endl;
    }

    size_t count = mySet.count(2);
    std::cout << "Number of elements with value 2: " << count << std::endl;

    // 插入和删除操作
    auto insertResult = mySet.insert(6);
    if (insertResult.second) {
        std::cout << "Insertion successful." << std::endl;
    }

    auto eraseIt = mySet.find(4);
    if (eraseIt != mySet.end()) {
        mySet.erase(eraseIt);
        std::cout << "Element erased." << std::endl;
    }

    mySet.clear();

    // 桶操作
    size_t bucketCount = mySet.bucket_count();
    size_t bucketSize = mySet.bucket_size(2);
    size_t valueBucket = mySet.bucket(5);

    std::cout << "Bucket count: " << bucketCount << std::endl;
    std::cout << "Bucket size at index 2: " << bucketSize << std::endl;
    std::cout << "Bucket of value 5: " << valueBucket << std::endl;

    // 哈希策略
    float loadFactor = mySet.load_factor();
    float maxLoadFactor = mySet.max_load_factor();

    std::cout << "Load factor: " << loadFactor << std::endl;
    std::cout << "Max load factor: " << maxLoadFactor << std::endl;

    mySet.rehash(10);
    mySet.reserve(20);

    return 0;
}