C++ —— unordered_set、unordered_map的介绍及使用_c++中unorderedset的用法

unordered_set<int> us1; //构造int类型的空容器

unordered_set<int> us2(us1); //拷贝构造同类型容器us1的复制品

string str("abcedf");
unordered_set<char> us3(str.begin(), str.end()); //构造string对象某段区间的复制品

#include <unordered_set>
#include <iostream>
 
int main() {
    // 定义一个存储int类型元素的unordered_set
    std::unordered_set<int> mySet;
    
    // 插入元素
    mySet.insert(1);
    mySet.insert(2);
    mySet.insert(3);
 
    // 打印元素
    for (const auto& elem : mySet) {
        std::cout << elem << " ";
    }
 
    return 0;
}

#include <iostream>
#include <unordered_set>
 
using namespace std;
 
int main() {
    unordered_set<int> us;
 
    // 插入元素（自动去重）
    us.insert(1);
    us.insert(4);
    us.insert(3);
    us.insert(3); // 重复元素，不会插入
    us.insert(2);
    us.insert(2); // 重复元素，不会插入
    us.insert(3); // 重复元素，不会插入
 
    // 遍历容器方式一（范围for）
    for (auto e : us) {
        cout << e << " ";
    }
    cout << endl; // 1 4 3 2（元素顺序可能会不同，因为是无序的）
 
    // 删除元素方式一
    us.erase(3); // 删除值为3的元素
 
    // 删除元素方式二
    unordered_set<int>::iterator pos = us.find(1); // 查找值为1的元素
    if (pos != us.end()) {
        us.erase(pos); // 删除找到的元素
    }
 
    // 遍历容器方式二（迭代器遍历）
    unordered_set<int>::iterator it = us.begin();
    while (it != us.end()) {
        cout << *it << " ";
        it++;
    }
    cout << endl; // 4 2（元素顺序可能会不同，因为是无序的）
 
    // 容器中值为2的元素个数
    cout << us.count(2) << endl; // 1
 
    // 容器大小
    cout << us.size() << endl; // 2
 
    // 清空容器
    us.clear();
 
    // 容器判空
    cout << us.empty() << endl; // 1（true）
 
    // 交换两个容器的数据
    unordered_set<int> tmp{11, 22, 33, 44};
    us.swap(tmp);
    for (auto e : us) {
        cout << e << " ";
    }
    cout << endl; // 11 22 33 44（元素顺序可能会不同，因为是无序的）
 
    return 0;
}

#include <iostream>
#include <unordered_set>
using namespace std;
 
int main()
{
	unordered_multiset<int> ums;
	//插入元素（允许重复）
	ums.insert(1);
	ums.insert(4);
	ums.insert(3);
	ums.insert(3);
	ums.insert(2);
	ums.insert(2);
	ums.insert(3);
	for (auto e : ums)
	{
		cout << e << " ";
	}
	cout << endl; //1 4 3 3 3 2 2
	return 0;
}

unordered_map<int, double> um1; //构造一个key为int类型，value为double类型的空容器

unordered_map<int, double> um2(um1); //拷贝构造同类型容器um1的复制品

unordered_map<int, double> um3(um2.begin(), um2.end()); //使用迭代器拷贝构造um2容器某段区间的复制品

#include <unordered_map>
#include <iostream>
 
int main() {
    // 定义一个键为string类型，值为int类型的unordered_map
    std::unordered_map<std::string, int> myMap;
    
    // 插入键值对
    myMap["one"] = 1;
    myMap["two"] = 2;
    myMap["three"] = 3;
 
    // 打印键值对
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
 
    return 0;
}

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;
 
int main()
{
	unordered_map<int, string> um;
	//插入键值对方式一：构造匿名对象插入
	um.insert(pair<int, string>(1, "one"));
	um.insert(pair<int, string>(2, "two"));
	um.insert(pair<int, string>(3, "three"));
	//遍历方式一：范围for
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //1->one 2->two 3->three
	//插入键值对方式二：调用make_pair函数模板插入
	um.insert(make_pair(4, "four"));
	um.insert(make_pair(5, "five"));
	um.insert(make_pair(6, "six"));
	//遍历方式二：迭代器遍历
	unordered_map<int, string>::iterator it = um.begin();
	while (it != um.end())
	{
		cout << it->first << "->" << it->second << " ";
		it++;
	}
	cout << endl; //1->one 2->two 3->three 4->four 5->five 6->six
	//插入键值对方式三：利用[]运算符重载函数进行插入（常用）
	um[7] = "seven";
	um[8] = "eight";
	um[9] = "nine";
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //9->nine 1->one 2->two 3->three 4->four 5->five 6->six 7->seven 8->eight
	//删除键值对方式一：根据key值删除
	um.erase(5);
	//删除键值对方式二：根据迭代器删除
	unordered_map<int, string>::iterator pos = um.find(7); //查找键值为7的键值对
	if (pos != um.end())
	{
		um.erase(pos);
	}
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //9->nine 1->one 2->two 3->three 4->four 6->six 8->eight
	//修改键值对方式一：通过find获得迭代器，通过迭代器修改
	pos = um.find(1);
	if (pos != um.end())
	{
		pos->second = "one/first";
	}
	//修改键值对方式二：利用[]运算符重载函数进行修改（常用）
	um[2] = "two/second";
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //9->nine 1->one/first 2->two/second 3->three 4->four 6->six 8->eight
	//容器中key值为3的键值对的个数
	cout << um.count(3) << endl;
	//容器的大小
	cout << um.size() << endl;
	//清空容器
	um.clear();
	//容器判空
	cout << um.empty() << endl;
	//交换两个容器的数据
	unordered_map<int, string> tmp{ { 2021, "before" }, { 2022, "now" } };
	um.swap(tmp);
	for (auto e : um)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //2021->before 2022->now
	return 0;
}

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;
 
int main()
{
	unordered_multimap<int, string> umm;
	//插入键值对（允许键值重复）
	umm.insert(make_pair(2022, "吃饭"));
	umm.insert(make_pair(2022, "睡觉"));
	umm.insert(make_pair(2022, "敲代码"));
	for (auto e : umm)
	{
		cout << e.first << "->" << e.second << " ";
	}
	cout << endl; //2022->吃饭 2022->睡觉 2022->敲代码
	return 0;
}