c++中 unordered_map 与 unordered_set 用法指南

最新推荐文章于 2024-06-24 19:18:08 发布
最新推荐文章于 2024-06-24 19:18:08 发布
阅读量1.1k 收藏 15
点赞数 20
分类专栏： C/C++ 文章标签： c++ 数据结构 哈希表 算法 unordered_map unordered_set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanceyxin/article/details/139374598
版权

unordered_map 与 unordered_set 区别与联系

unordered_map 和 unordered_set 都是 C++ 标准模板库（STL）中的容器，它们使用哈希表作为底层数据结构，提供了快速的查找、插入和删除操作。下面是它们之间的联系与区别：

联系

  1. 底层实现：两者都基于哈希表实现，利用了哈希函数来分布元素。
  2. 性能特点：它们都提供平均时间复杂度为 O(1) 的查找、插入和删除操作。
  3. 冲突解决：两者都使用某种形式的链表或红黑树来解决哈希冲突。
  4. 非线性容器：它们都是非线性容器，不保证元素的顺序。

区别

  1. 存储内容：

    • unordered_map 存储键值对，即每个元素包含一个键（key）和一个值（value），键是唯一的。
    • unordered_set 只存储唯一的值，不包含键。

  2. 用途：

    • unordered_map 适用于需要通过键来访问或存储数据的场景，类似于关联数组或字典。
    • unordered_set 适用于需要存储唯一元素集合的场景，类似于集合。

  3. 操作：

    • unordered_map 支持通过键来访问、插入、删除和查找值。
    • unordered_set 支持插入、删除和查找元素。

  4. 内存使用：

    • unordered_map 由于需要存储键和值，通常比 unordered_set 使用更多的内存。

  5. 迭代器：

    • unordered_map 的迭代器可以解引用为一个 pair，其中包含键和值。
    • unordered_set 的迭代器只能解引用为一个值。

  6. 示例：
    在这里插入图片描述

  7. 元素查找：

    • unordered_map 的 find 方法返回一个迭代器，指向键值对，可以访问键和值。
    • unordered_set 的 find 方法返回一个迭代器，指向集合中的元素。

使用场景

  • 当你需要一个键来快速访问数据时，使用 unordered_map。
  • 当你只需要存储一组不包含重复元素的数据时，使用 unordered_set。

总的来说，unordered_map 和 unordered_set 在实现上有很多相似之处，但它们服务于不同的数据存储需求。选择使用哪一个取决于你的具体应用场景和需求。

unordered_map

unordered_map 是 C++ 中的一个关联容器，它存储了键值对，并且提供了快速的数据访问能力。

  1. 基本使用：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap;
    umap[1] = "one";
    umap[2] = "two";
    umap[3] = "three";

    // 打印所有键值对
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
}
  • 输出结果：

1: one
2: two
3: three
在这里插入图片描述

  1. 初始化列表：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap = {
        {1, "one"},
        {2, "two"},
        {3, "three"}
    };

    // 打印所有键值对
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
}
  • 输出结果：

1: one
2: two
3: three
在这里插入图片描述

  1. 访问元素：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap = {
        {1, "one"},
        {2, "two"}
    };

    // 访问元素
    std::cout << "Value for key 1: " << umap[1] << std::endl;
    // 访问不存在的键将自动插入该键，并为其分配一个默认值
    std::cout << "Value for key 3: " << umap[3] << std::endl; // 默认值，例如空字符串
}
  • 输出结果：

Value for key 1: one
Value for key 3:
在这里插入图片描述

  1. 检查键是否存在：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap = {
        {1, "one"},
        {2, "two"}
    };

    int key = 1;
    if (umap.find(key) != umap.end()) {
        std::cout << "Key " << key << " exists." << std::endl;
    }
    else {
        std::cout << "Key " << key << " does not exist." << std::endl;
    }
}
  • 输出结果：

Key 1 exists.
在这里插入图片描述

  1. 删除元素：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap = {
        {1, "one"},
        {2, "two"}
    };

    int keyToRemove = 1;
    auto it = umap.find(keyToRemove);
    if (it != umap.end()) {
        umap.erase(it);
    }

    // 打印删除元素后的映射
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
}
  • 输出结果：

2: two
在这里插入图片描述

  1. 使用 emplace 插入元素：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap;

    // 使用 emplace 插入元素
    auto result = umap.emplace(1, "one");
    if (result.second) {
        std::cout << "Insert successful." << std::endl;
    }

    // 尝试再次插入相同的键
    result = umap.emplace(1, "uno");
    if (!result.second) {
        std::cout << "Insert failed, key already exists." << std::endl;
    }

    // 打印映射
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
}
  • 输出结果：

Insert successful.
Insert failed, key already exists.
1: one
在这里插入图片描述

  1. 遍历 unordered_map：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap = {
        {1, "one"},
        {2, "two"},
        {3, "three"}
    };

    // 使用范围 for 循环遍历
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 使用迭代器遍历
    for (auto it = umap.begin(); it != umap.end(); ++it) {
        std::cout << it->first << ": " << it->second << std::endl;
    }
}
  • 输出结果：

1: one
2: two
3: three
1: one
2: two
3: three
在这里插入图片描述

  1. 使用 unordered_map 的 size 和 empty：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> umap = {
        {1, "one"},
        {2, "two"}
    };

    std::cout << "Size of umap: " << umap.size() << std::endl;
    std::cout << "Is umap empty? " << (umap.empty() ? "Yes" : "No") << std::endl;
}
  • 输出结果：

Size of umap: 2
Is umap empty? No
在这里插入图片描述

unordered_set

  1. 基本使用：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset;
    uset.insert(10);
    uset.insert(20);
    uset.insert(30);

    std::cout << "Size of uset: " << uset.size() << std::endl;
}
  • 输出结果：

Size of uset: 3
在这里插入图片描述

  1. 初始化列表：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset = { 10, 20, 30, 40, 50 };

    for (int num : uset) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}
  • 输出结果:

50 10 20 30 40
在这里插入图片描述

  1. 检查元素是否存在：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset = { 1, 2, 3 };

    int key = 2;
    if (uset.find(key) != uset.end()) {
        std::cout << "Element " << key << " exists in uset." << std::endl;
    }
    else {
        std::cout << "Element " << key << " does not exist in uset." << std::endl;
    }
}
  • 输出结果：

Element 2 exists in uset.
在这里插入图片描述

  1. 删除元素：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset = { 1, 2, 3 };

    int keyToRemove = 2;
    if (uset.erase(keyToRemove)) {
        std::cout << "Element removed from uset." << std::endl;
    }
    else {
        std::cout << "Element not found in uset." << std::endl;
    }

    for (int num : uset) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}
  • 输出结果：

Element removed from uset.
1 3
在这里插入图片描述

  1. 使用 emplace 插入元素：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset;

    // 使用 emplace 插入元素
    auto result = uset.emplace(10);
    if (result.second) {
        std::cout << "Insert successful." << std::endl;
    }

    // 尝试再次插入相同的元素
    result = uset.emplace(10);
    if (!result.second) {
        std::cout << "Insert failed, element already exists." << std::endl;
    }
}
  • 输出结果：

Insert successful.
Insert failed, element already exists.
在这里插入图片描述

  1. 遍历 unordered_set：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset = { 5, 10, 15, 20, 25 };

    // 使用范围 for 循环遍历
    for (int num : uset) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 使用迭代器遍历
    for (auto it = uset.begin(); it != uset.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}
  • 输出结果：

5 10 15 20 25
5 10 15 20 25
在这里插入图片描述

  1. 使用 unordered_set 的 size 和 empty：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset = { 1, 2, 3 };

    std::cout << "Size of uset: " << uset.size() << std::endl;
    std::cout << "Is uset empty? " << (uset.empty() ? "Yes" : "No") << std::endl;
}
  • 输出结果：

Size of uset: 3
Is uset empty? No
在这里插入图片描述

  1. 清空 unordered_set：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> uset = { 1, 2, 3, 4, 5 };

    uset.clear(); // 清空 uset

    std::cout << "Is uset empty after clear? " << (uset.empty() ? "Yes" : "No") << std::endl;
}
  • 输出结果：

Is uset empty after clear? Yes
在这里插入图片描述

  1. 自定义哈希函数：
#include <iostream>
#include <unordered_set>

// 自定义哈希函数
struct custom_hash {
    std::size_t operator()(int x) const {
        return std::hash<int>()(x);
    }
};

int main() {
    std::unordered_set<int, custom_hash> uset = { 1, 2, 3 };

    for (int num : uset) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}
  • 输出结果：

1 2 3
在这里插入图片描述

Codec Conductor
关注
  • 20
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
unordered_flat_set:C ++连续内存哈希容器。-开源
04-25
连续内存开放式寻址/封闭式散列，带有线性探测，容器。 基本上是unordered_set，unordered_map，unordered_multiset和unordered_multimap，但具有类似内存分配的向量。
C++中unordered_map,unordered_set,map和set的用法和区别
专心扫地
01-22 2133
参考链接： https://blog.csdn.net/zjajgyy/article/details/65935473 unordered_map和map unordered_map存储机制是哈希表，，即unordered_map内部元素是无序的。 map是红黑树，map中的元素是按照二叉搜索树存储，进行中序遍历会得到有序遍历。 unordered_set和set unordered_s...
【C++】【总结】unordered_map,unordered_set,map和set的用法和区别
READLEAF的博客
07-25 1176
转载出处：https://blog.csdn.net/zjajgyy/article/details/65935473 通过代码来区别 unordered_map和map unordered_map存储机制是哈希表，，即unordered_map内部元素是无序的。 map是红黑树，map中的元素是按照二叉搜索树存储，进行中序遍历会得到有序遍历。 unordered_set和set unordered_set基于哈希表，是无序的。 set实现了红黑树的平衡二叉检索树的数据结构，插入元素时，它会自动调整二叉树的
set、map、unordered_set、unordered_map区分
ଳxin的博客
12-03 463
1. set实现了红黑树的平衡二叉检索树的数据结构. find查找效率高>>>比要查找的值小就去左子树查找，反之则去右子树查找。 2. unordered_set基于哈希表，无自动排序功能。底层实现上，使用一个下标范围比较大的数组来存储元素，形成很多的桶，利 用hash函数对key进行映射到不同区域进行保存。 3. map是红黑树...
C++：map,unordered_map,set和unordered_set的用法和区别
bryant_zhang的博客
12-24 8326
一、map 内部实现机理 map内部实现了一个 红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二叉搜索树）， 红黑树具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素。因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行的操作。map中的元素是按照二叉搜索树（又名二叉查找树、二叉排序树，特点就是左子树上所有节点的键值都小于根节点的键值，右子树所有节点的键值都大于根节点的键值）存储的，使用中序遍历可将键值按照从小到大遍历出来。 优
C++中map、hash_map、unordered_map、unordered_set通俗辨析
热门推荐
Eleven的专栏
04-06 2万+
标题中提到的四种容器，对于概念不清的人来说，经常容易弄混淆。这里我不去把库里面复杂的原码拿出剖析，这个如果有兴趣其实完全可以查C++Reference,网上的原码是最权威和细致的了，而且我觉得有耐心直接认真看原码的人，也不需要我这篇速记博文了，所以我这里还是讲的通俗一些，把它们区分的七七八八。 一、hash_map、unordered_map 这两个的内部结构都是采用哈希表来实现。区别在哪里？
robin-hood-hashing：基于C ++ 11141720的基于robin hood哈希的快速且内存高效的哈希表
01-30
robin_hood::unordered_map和robin_hood::unordered_set是std::unordered_map / std::unordered_set独立于平台的替代品，对于实际的用例而言，它既更快，更高效。 安装及使用 直接纳入 将添加到您的C ++项目。 ...
sparsepp:用于 C++ 的快速、内存高效的哈希映射
05-29
unordered_map 和 unordered_set 的替代方案。 极低的内存使用量（通常每个条目大约一个字节的开销），最重要的是调整大小时非常小的内存开销。 非常高效，通常比编译器的无序映射/集或 Boost 更快。 C++11 支持...
parallel-hashmap:一系列仅标头，非常快速且对内存友好的hashmap和btree容器
04-28
替换std::unordered_map ， std::unordered_set ， std::map和std::set 需要具有C ++ 11支持的编译器，提供了C ++ 14和C ++ 17 API（例如try_emplace ） 非常高效，比编译器的无序映射/集合或Boost或显着更快 ...
C++ STL入门教程(6) set(集合)的使用方法
08-29
如果需要存储键值对应的关系，那么应该使用map或unordered_map。 总的来说，C++ STL中的set集合是一个强大且灵活的数据结构，适用于需要快速查找唯一元素的场景。理解并熟练掌握set的使用，能帮助开发者编写出更加...
unordered_set和unordered_map用法详解
谢白羽
07-17 9066
文章目录1.unordered_map1.介绍2.性质3.模板4.定义迭代器5.功能函数5.1构造函数5.2 容量操作：size、empty5.3 元素操作：find、insert、at、erase、clear、swap、for循环打印5.4 迭代器和bucket操作2.unordered_set2.1性质2.2 unordered_set函数2.2.1 构造函数2.2.2 迭代器2.2.3 各种操作2.3 代码使用案例 ： 1.unordered_map 1.介绍 最近使用到一个c++的容器——unor
C语言第17篇：预处理详解
2302_78977491的博客
06-22 772
C语言设置了一些预定义符号，可以直接使用。预定义符号也是在预处理期间处理的。__FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1, 否则未定义int main()printf("进行编译的源文件:%s\n", __FILE__);printf("当前文件的行号:%d\n", __LINE__);
什么野指针（c++）
qq_35374791的博客
06-24 7234
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
C++之std::queue::emplace
jzjhome的博客
06-22 442
是 C++ STL 中std::queue容器的成员函数，它用于在队列的末尾就地构造一个新元素。这个函数类似于，但是emplace允许你通过传递参数来构造元素，而不需要显式地创建一个元素对象。
makefile文件编写（C）
baidu_34971492的博客
06-24 226
这个Makefile定义了如何编译和链接你的程序。CC变量指定了编译器（这里是gcc），CFLAGS变量包含了编译器的标志，比如警告选项和调试信息，LDFLAGS变量用于链接时的选项。运行Makefile：在命令行中运行make命令，Makefile会根据其规则自动编译和链接你的程序。
C++ TheadPool 线程池实现
GodJhin的博客
06-21 841
此情况发生情形3且设置了任务缓冲队列大小后面，主程序添加第N个任务，添加后发现池子中的线程用完了，任务缓冲队列也满了，于是进入等待状态、等待任务缓冲队列中的任务腾空通知。此情况基于情形1，所有工作线程已处在等待状态，主线程开始添加三个任务，添加后通知(notif())唤醒线程池中的线程开始取(take())任务执行. 此时的任务缓冲队列还是空。此情况发生情形2后面，所有工作线程都在工作中，主线程开始添加第四个任务，添加后发现现在线程池中的线程用完了，于是存入任务缓冲队列。
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
dvlinker的技术专栏
06-24 38
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
0621# C++八股 1.成员初始化列表的概念？以及为什么使用它会快一点？2.重写Override和重载Overload区别
qq_52784762的博客
06-21 701
成员初始化列表：用于在构造函数体执行之前初始化成员变量，提供更高效的初始化方式。直接初始化 vs. 赋值初始化：直接初始化避免了多余的默认构造和赋值操作，提高了性能。使用场景：特别适用于必须初始化的成员变量（如常量和引用），以及需要提高效率的情况。
Android C++系列：C++最佳实践5const
最新发布
轻口味的专栏
06-24 1295
本文介绍了const与宏定义常量的区别，以及const修饰变量的注意事项，绑定常量的引用、指向常量的指针和常量指针。并介绍了顶层const与底层const的区别。
c++ map,unordered_map,set,unordered_set
07-28
回答: 在C++中，map、unordered_map、set和unordered_set都是STL（标准模板库）中的容器。它们都用于存储一组数据，并提供了不同的功能和性能特点。 map是一个有序的关联容器，它使用红黑树实现，可以根据键值进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Codec Conductor

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

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

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

打赏作者

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

抵扣说明：

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

余额充值