数据结构算法刷题笔记——二、2.2 map 与 unordered_map

最新推荐文章于 2023-11-12 19:52:23 发布
最新推荐文章于 2023-11-12 19:52:23 发布
阅读量599 收藏
点赞数
分类专栏： 数据结构算法刷题笔记 文章标签： 数据结构 算法 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45029825/article/details/132793240
版权

数据结构算法刷题笔记——二、2.2 map 与 unordered_map

1 unordered_map

1.1 unordered_map简介

  • unordered_map是C++标准库提供的关联容器之一，保存的是键值对（key-value），可以高效的根据单个key值查找对应的value
  • key 值应该是唯一的，key和value 的数据类型可以不相同
  • 键(key;it->first)-值(value;it->second)
  • unordered_map 底层使用的数据结构是哈希表 （hash table）, 存储元素时是没有顺序的，只是根据key的哈希值，将元素存在指定位置，所以根据key查找单个value时非常高效，平均可以在常数时间内完成
  • unordered_map中查找、添加或删除元素时间复杂度都是常数时间O(1)
  • unordered_map 查询单个key的时候效率比map高，但是要查询某一范围内的key值时，比map效率低
  • unordered_map 和 map 是关联容器的一种，map是由一个个pair组成
  • 为什么用map和unordered_map不用二维数组 ：数组查找的时间复杂度较大O(n)，map和unordered_map的时间复杂度位O(1)
  • 为什么有map还需要unordered_map：
    • map基于红黑树，是按关键字有序排列的
    • unordered_map基于哈希表，是散列存放的（无序）
    • 需要进行范围查询，那么使用map就更方便，因为map中元素已经按照关键字有序排好了，但是如果这种场景下使用unordered_map，你要进行范围查找只能一个一个去比较了
    • 在进行等值查询时unordered_map只需要O(1)的时间就能查到，但map却需要O(log(n))的时间，因此等值查询时使用unordered_map更快

1.2 unordered_map 的一个元素pair

学习关联容器（map、unordered_map……）之前，我们需要先了解名为pair 的标准库类型。

  • 一个pair保存两个数据成员
    • 第一个成员是first
    • 第二个成员是second

1.2.1 pair 用法

1.2.1.1 pair 创建及初始化
  • pair<T1,T2> p;
    • 创建一个pair，包含两个已经被默认初始化的，类型分别为T1、T2的成员
  • pair<T1,T2> p(v1,v2);;
    • 创建一个pair，first成员的类型为T1，值为v1，second成员的类型为T2，值为v2
  • pair<T1,T2> p={v1,v2};
    • 创建一个pair，first成员的类型为T1，值为v1，second成员的类型为T2，值为v2
  • make_pair(v1,v2);
    • 返回一个用v1和v2初始化的pair，pair的类型从v1和v2的类型推断出来
  • p.first;
    • 返回p的first数据成员
  • p.second;
    • 返回p的second数据成员
pair<string, string> p1("sc0301","小杨");	            // 方式一，创建一个pair名为p1
pair<string, string> p2 = make_pair("sc0302", "小马");	// 方式二，make_pair函数返回一个用"sc0302"和 "小马"初始化的pair
pair<string, string> p3("sc0303", "小王");
pair<string, string> p4("sc0304", "小何");

string p1_ID = p1.first;	  // 得到pair的第1个成员
string p1_name = p1.second;   // 得到pair的第2个成员

1.3 unordered_map 编程

1.3.0 头文件

#include <unordered_map>
using namespace std;

1.3.1 创建 unordered_map<T1,T2> 容器名;

  • T1、T2是类型名，可以是基本数据类型int、double等，也可以是类类型string等
  1. 创建一个名为m1的空unordered_map，key的类型为T1，value的类型为T2
unordered_map<T1,T2>   m1;
  1. m1中的元素被初始化为p1,p2……，p1、p2是pair类型
unordered_map<T1,T2>   m1{p1,p2……};
  1. m1中的元素被初始化为 键值对{key1,value1},{key2,value2}……
unordered_map<T1,T2>   m1{{key1,value1},{key2,value2}……};
  1. m2中包含和m1一样的元素
unordered_map<T1,T2>   m2(m1);
  1. m2中包含和m1一样的元素
unordered_map<T1,T2>   m2=m1;

pair<string, string> p1("sc0301","小杨");	            // 方式一，创建一个pair名为p1
pair<string, string> p2 = make_pair("sc0302", "小马");	// 方式二，make_pair函数返回一个用"sc0302"和 "小马"初始化的pair
pair<string, string> p3("sc0303", "小王");
pair<string, string> p4("sc0304", "小何");

unordered_map<string, string> m1;                 // 创建一个空unordered_map
unordered_map<string, string> m2{ p1,p2,p3,p4 };  // 创建一个包含键值对p1、p2、p3、p4的unordered_map
unordered_map<string, string> m3{ {"sc0301","小杨"},{"sc0302", "小马"},{"sc0303", "小王"},{"sc0304", "小何"} }; // 效果同上一句
unordered_map<string, string> m4(m2);   // 创建一个unordered_map，m4中包含和m2一样的元素
unordered_map<string, string> m5 = m2;  // 创建一个unordered_map，m5中包含和m2一样的元素

1.3.2 访问元素

  1. 得到关键字key对应的值value
T2 value = m1[key];
  1. 得到关键字key对应的值value
m1.at(key);
  1. 访问迭代器iter指向的元素
*iter

1.3.3 获取迭代器

  1. 获取指向m1首元素的迭代器
m1.begin();
  1. 获取指向m1尾元素的后一个位置的迭代器
m1.end();
  1. 获取指向m1首元素的前一个位置的迭代器
m1.rbegin();
  1. 获取指向m1尾元素的迭代器
m1.rend();
  1. 含义同上，但获取到的是const_iterator
m1.cbegin(); 
m1.cend();
  1. 含义同上，但获取到的是const_iterator
m1.crbegin(); 
m1.crend();

string p2_name = m2["sc0302"];	   // 得到学号（关键字）"sc0302"对应的姓名（值）
string p3_name = m2.at("sc0303");  // 得到学号"sc0303"对应的姓名	      

unordered_map<string, string>::iterator it1 = m2.begin();	 // 得到指向m2首元素的迭代器
unordered_map<string, string>::iterator it2 = m2.end();    // 得到指向m2尾元素的下一个位置的迭代器
pair<string, string> p11 = *it1;   // 得到m2的首元素{"sc0301","小杨"}
string p1_ID = it1->first;         // 得到m2的首元素{"sc0301","小杨"}的fisrt成员
string p1_name = it1->second;	   // 得到m2的首元素{"sc0301","小杨"}的second成员

1.3.4 遍历容器

  1. 使用迭代器
for (auto it_b = m2.begin(), it_e = m2.end(); it_b != it_e;++it_b) {
	pair<string, string> current = *it_b;
	cout << "学号：" << it_b->first << "; 姓名:" << it_b->second << endl;
	// 上面这一句等同于下面这一句
	cout << "学号：" << current.first << "; 姓名:" << current.second << endl;
}
  1. 范围for语句
for (auto p : m2) {
	cout << "学号：" << p.first << "; 姓名:" << p.second << endl;
}

1.3.5 添加、修改元素

插入元素

  1. 在unordered_map中插入已有的pair
m1.insert(p1);
  1. 在unordered_map中插入键值对{key1,value1}
m1.insert({key1,value1});
  1. 创建一个无名pair对象，并插入到unordered_map中
m1.insert(pair<T1, T2> (key1, value1));
  1. 创建一个无名pair对象，并插入到unordered_map中
m1.insert(make_pair(key1, value1));
  1. 创建一个无名pair对象，并插入到unordered_map中
m1.insert(unordered_map<T1, T2>::value_type (key1, value1));
  1. 在unordered_map中插入已有的pair
m1.emplace(p1);
  1. 创建一个无名pair对象，并插入到unordered_map中
m1.emplace(pair<T1, T2> (key1, value1));

修改元素

  1. 如果key不存在则插入该键值对，如果key已存在则修改该key对应的value
m1[key] = value;

m1.insert(p1);	                   // 在unordered_map中插入已有的pair
m1.insert({ "sc0302", "小马" });   // 插入键值对{ "sc0302", "小马" }
m1.insert(pair<string, string> ("sc0303", "小王"));  // 创建一个无名pair对象，并插入到unordered_map中	
m1.insert(make_pair("sc0303", "小王"));              // 要插入的关键字已在容器中，emplace/insert什么都不做
m1.insert(unordered_map<string, string>::value_type("sc0303", "小王"));   // 要插入的关键字已在容器中，emplace/insert什么都不做
m1["sc0304"] = "小何";             // 如果key不存在则插入该键值对，如果key已存在则修改该key对应的value。

m1.emplace(p1);			                             // 要插入的关键字已在容器中，emplace/insert什么都不做
m1.emplace(pair<string, string>("sc0303", "小王"));  // 要插入的关键字已在容器中，emplace/insert什么都不做

1.3.6 删除元素

  1. 删除关键字为key的元素
m1.erase(key)
  1. 删除迭代器iter指向的元素
m1.erase(iter);
  1. 删除迭代器iter1和ter2指向的范围中元素
m1.erase(iter1,iter2);
  1. 删除m1中的所有元素
m1.clear();

m1.erase("sc0301");		  // 删除关键字为"sc0301"的元素
auto iter = m1.begin();   // 指向m2的首元素的迭代器
m1.erase(iter);           // 删除迭代器指向的元素
auto iter1 = m1.begin(), iter2 = m1.end();
m1.erase(iter1, iter2);   // 删除迭代器iter1、iter2指向的范围中的元素
m2.clear();               // 删除容器中的全部元素

1.3.7 unordered_map的大小

  1. 获得m1的大小
m1.szie();
  1. 若m1为空返回值为true，否则返回值为false
m1.empty();

int s = m3.size();    // 获得m1的大小
bool e = m3.empty();  // 若m1为空返回值为true，否则返回值为false

1.3.8 查找

  1. 返回一个迭代器，指向第一个关键字为key的元素，若key不在容器中，则返回尾后迭代器
m1.find(key)
  1. 返回关键字等于key的元素的数量。对于不允许重复关键字的容器unordered_map，返回的值是0或1
m1.count(key);

unordered_map<string, string>::iterator it = m4.find("sc0301");  // 查找关键字为"sc0301"的元素,返回一个迭代器
if (it == m4.end()) {         // 若"sc0301"不在容器中，则it等于尾后迭代器
	cout << "未找到！" << endl;
}
else {
	pair<string, string> result1 = *it;	// 找到了
}

int result2 = m4.count("sc0305");  // 查找关键字为"sc0301"的元素,返回关键字等于"sc0301"的元素数量
if (result2==0) {
	cout << "未找到！" << endl;
}
else {
	cout << "找到了！" << endl;
}

unordered_map<string, string>::iterator it_up = m4.upper_bound("sc0301");  // 返回一个迭代器，指向第一个关键字大于"sc0301"的元素
pair<string, string> result3 = *it_up;

1.3.9 程序示例

#include <iostream>
#include <string>
#include <utility>
#include <unordered_map>

using namespace std;

int main() {	
	// 初始化-----------------------------------------------------------------------------------
	pair<string, string> p1("sc0301","小杨");	            // 方式一，创建一个pair名为p1
	pair<string, string> p2 = make_pair("sc0302", "小马");	// 方式二，make_pair函数返回一个用"sc0302"和 "小马"初始化的pair
	pair<string, string> p3("sc0303", "小王");
	pair<string, string> p4("sc0304", "小何");

	unordered_map<string, string> m1;                 // 创建一个空unordered_map
	unordered_map<string, string> m2{ p1,p2,p3,p4 };  // 创建一个包含键值对p1、p2、p3、p4的unordered_map
	unordered_map<string, string> m3{ {"sc0301","小杨"},{"sc0302", "小马"},{"sc0303", "小王"},{"sc0304", "小何"} }; // 效果同上一句
	unordered_map<string, string> m4(m2);   // 创建一个unordered_map，m4中包含和m2一样的元素
	unordered_map<string, string> m5 = m2;  // 创建一个unordered_map，m5中包含和m2一样的元素

	// 访问元素-----------------------------------------------------------------------------------
	string p2_name = m2["sc0302"];	   // 得到学号（关键字）"sc0302"对应的姓名（值）	
	string p3_name = m2.at("sc0303");  // 得到学号"sc0303"对应的姓名	      
	
	unordered_map<string, string>::iterator it1 = m2.begin();	 // 得到指向m2首元素的迭代器
	unordered_map<string, string>::iterator it2 = m2.end();    // 得到指向m2尾元素的下一个位置的迭代器
	pair<string, string> p11 = *it1;   // 得到m2的首元素{"sc0301","小杨"}
	string p1_ID = it1->first;         // 得到m2的首元素{"sc0301","小杨"}的fisrt成员
	string p1_name = it1->second;	   // 得到m2的首元素{"sc0301","小杨"}的second成员

	// 遍历容器-----------------------------------------------------------------------------------
	for (auto it_b = m2.begin(), it_e = m2.end(); it_b != it_e;++it_b) {
		pair<string, string> current = *it_b;
		cout << "学号：" << it_b->first << "; 姓名:" << it_b->second << endl;
		// 上面这一句等同于下面这一句
		cout << "学号：" << current.first << "; 姓名:" << current.second << endl;
	}

	for (auto p : m2) {
		cout << "学号：" << p.first << "; 姓名:" << p.second << endl;
	}

	// 添加、修改元素-----------------------------------------------------------------------------------
	m1.insert(p1);	                   // 在unordered_map中插入已有的pair
	m1.insert({ "sc0302", "小马" });   // 插入键值对{ "sc0302", "小马" }
	m1.insert(pair<string, string> ("sc0303", "小王"));  // 创建一个无名pair对象，并插入到unordered_map中	
	m1.insert(make_pair("sc0303", "小王"));              // 要插入的关键字已在容器中，emplace/insert什么都不做
	m1.insert(unordered_map<string, string>::value_type("sc0303", "小王"));   // 要插入的关键字已在容器中，emplace/insert什么都不做
	m1["sc0304"] = "小何";             // 如果key不存在则插入该键值对，如果key已存在则修改该key对应的value。

	m1.emplace(p1);			                             // 要插入的关键字已在容器中，emplace/insert什么都不做
	m1.emplace(pair<string, string>("sc0303", "小王"));  // 要插入的关键字已在容器中，emplace/insert什么都不做

	// 删除元素-----------------------------------------------------------------------------------
	m1.erase("sc0301");		  // 删除关键字为"sc0301"的元素
	auto iter = m1.begin();   // 指向m2的首元素的迭代器
	m1.erase(iter);           // 删除迭代器指向的元素
	auto iter1 = m1.begin(), iter2 = m1.end();
	m1.erase(iter1, iter2);   // 删除迭代器iter1、iter2指向的范围中的元素
	m2.clear();               // 删除容器中的全部元素

	// 大小-----------------------------------------------------------------------------------
	int s = m3.size();    // 获得m1的大小
	bool e = m3.empty();  // 若m1为空返回值为true，否则返回值为false

	// 查找-----------------------------------------------------------------------------------
	unordered_map<string, string>::iterator it = m4.find("sc0301");  // 查找关键字为"sc0301"的元素,返回一个迭代器
	if (it == m4.end()) {         // 若"sc0301"不在容器中，则it等于尾后迭代器
		cout << "未找到！" << endl;
	}
	else {
		pair<string, string> result1 = *it;	// 找到了
	}

	int result2 = m4.count("sc0305");  // 查找关键字为"sc0301"的元素,返回关键字等于"sc0301"的元素数量
	if (result2==0) {
		cout << "未找到！" << endl;
	}
	else {
		cout << "找到了！" << endl;
	}
}

2 map

1.1 map简介

  • map是C++标准库提供的关联容器之一
    • 保存的是键值对（key-value）
    • 可以通过key快速查找到其对应的value
  • map底层使用的数据结构是红黑树
    • 在map中查找、添加或删除元素时间复杂度都是O(log(n))
    • map中的元素还是有序的
  • 为什么用map和map不用二维数组 ：数组查找的时间复杂度较大O(n)，map和unordered_map的时间复杂度位O(1)
  • 为什么有map还需要map：
    • map基于红黑树，是按关键字有序排列的
    • 红黑树是一种自平衡的二叉搜索树，只需要**O(log(n))**的时间就能查到对应的值
    • 如果用的二维数组保存的，需要从头遍历二维数组的第一列，需要O(n)的时间才能查到。这就是使用map的意义。

1.2 map 的一个元素pair

学习关联容器（map、unordered_map……）之前，我们需要先了解名为pair 的标准库类型。

  • 一个pair保存两个数据成员
    • 第一个成员是first
    • 第二个成员是second

1.2.1 pair 用法

1.2.1.1 pair 创建及初始化
  • pair<T1,T2> p;
    • 创建一个pair，包含两个已经被默认初始化的，类型分别为T1、T2的成员
  • pair<T1,T2> p(v1,v2);;
    • 创建一个pair，first成员的类型为T1，值为v1，second成员的类型为T2，值为v2
  • pair<T1,T2> p={v1,v2};
    • 创建一个pair，first成员的类型为T1，值为v1，second成员的类型为T2，值为v2
  • make_pair(v1,v2);
    • 返回一个用v1和v2初始化的pair，pair的类型从v1和v2的类型推断出来
  • p.first;
    • 返回p的first数据成员
  • p.second;
    • 返回p的second数据成员
pair<string, string> p1("sc0301","小杨");	            // 方式一，创建一个pair名为p1
pair<string, string> p2 = make_pair("sc0302", "小马");	// 方式二，make_pair函数返回一个用"sc0302"和 "小马"初始化的pair
pair<string, string> p3("sc0303", "小王");
pair<string, string> p4("sc0304", "小何");

string p1_ID = p1.first;	  // 得到pair的第1个成员
string p1_name = p1.second;   // 得到pair的第2个成员

1.3 map 编程

1.3.0 头文件

#include <map>
using namespace std;

1.3.1 初始化

  1. T1、T2是类型名，可以是基本数据类型int、double等，也可以是类类型string等
map<T1,T2>    容器名;
  1. 创建一个名为m1的空map，key的类型为T1，value的类型为T2
map<T1,T2>   m1;
  1. m1中的元素被初始化为p1,p2……，p1、p2是pair类型
map<T1,T2>   m1{p1,p2……};
  1. m1中的元素被初始化为 键值对{key1,value1},{key2,value2}……
map<T1,T2>   m1{{key1,value1},{key2,value2}……};
  1. m2中包含和m1一样的元素
map<T1,T2>   m2(m1);
  1. m2中包含和m1一样的元素
map<T1,T2>   m2=m1;

pair<string, string> p1("sc0301","小杨");	            // 方式一，创建一个pair名为p1
pair<string, string> p2 = make_pair("sc0302", "小马");	// 方式二，make_pair函数返回一个用"sc0302"和 "小马"初始化的pair
pair<string, string> p3("sc0303", "小王");
pair<string, string> p4("sc0304", "小何");

map<string, string> m1;                 // 创建一个空map
map<string, string> m2{ p1,p2,p3,p4 };  // 创建一个包含键值对p1、p2、p3、p4的map
map<string, string> m3{ {"sc0301","小杨"},{"sc0302", "小马"},{"sc0303", "小王"},{"sc0304", "小何"} }; // 效果同上一句
map<string, string> m4(m2);   // 创建一个map，m4中包含和m2一样的元素
map<string, string> m5 = m2;  // 创建一个map，m5中包含和m2一样的元素

1.3.1 访问元素

  1. 得到关键字key对应的值value
T2 value = m1[key];
  1. 得到关键字key对应的值value
m1.at(key);
  1. 访问迭代器iter指向的元素
*iter

1.3.2 获取迭代器

  1. 获取指向m1首元素的迭代器
m1.begin();
  1. 获取指向m1尾元素的后一个位置的迭代器
m1.end();
  1. 获取指向m1首元素的前一个位置的迭代器
m1.rbegin();
  1. 获取指向m1尾元素的迭代器
m1.rend();
  1. 含义同上，但获取到的是const_iterator
m1.cbegin(); m1.cend();
  1. 含义同上，但获取到的是const_iterator
m1.crbegin(); m1.crend();

string p2_name = m2["sc0302"];	   // 得到学号（关键字）"sc0302"对应的姓名（值）
string p3_name = m2.at("sc0303");  // 得到学号"sc0303"对应的姓名	      

map<string, string>::iterator it1 = m2.begin();	 // 得到指向m2首元素的迭代器
map<string, string>::iterator it2 = m2.end();    // 得到指向m2尾元素的下一个位置的迭代器
pair<string, string> p11 = *it1;   // 得到m2的首元素{"sc0301","小杨"}
string p1_ID = it1->first;         // 得到m2的首元素{"sc0301","小杨"}的fisrt成员
string p1_name = it1->second;	   // 得到m2的首元素{"sc0301","小杨"}的second成员

1.3.3 遍历容器

  1. 使用迭代器
for (auto it_b = m2.begin(), it_e = m2.end(); it_b != it_e;++it_b) {
	pair<string, string> current = *it_b;
	cout << "学号：" << it_b->first << "; 姓名:" << it_b->second << endl;
	// 上面这一句等同于下面这一句
	cout << "学号：" << current.first << "; 姓名:" << current.second << endl;
}
  1. 范围for语句
for (auto p : m2) {
	cout << "学号：" << p.first << "; 姓名:" << p.second << endl;
}

1.3.4 添加、修改元素

  1. 在map中插入已有的pair
m1.insert(p1);
  1. 在map中插入键值对{key1,value1}
m1.insert({key1,value1});
  1. 创建一个无名pair对象，并插入到map中
m1.insert(pair<T1, T2> (key1, value1));
  1. 创建一个无名pair对象，并插入到map中
m1.insert(make_pair(key1, value1));
  1. 创建一个无名pair对象，并插入到map中
m1.insert(map<T1, T2>::value_type (key1, value1));
  1. 如果key不存在则插入该键值对，如果key已存在则修改该key对应的value
m1[key] = value;
  1. 在map中插入已有的pair
m1.emplace(p1);
  1. 创建一个无名pair对象，并插入到map中
m1.emplace(pair<T1, T2> (key1, value1));

m1.insert(p1);	                   // 在map中插入已有的pair
m1.insert({ "sc0302", "小马" });   // 插入键值对{ "sc0302", "小马" }
m1.insert(pair<string, string> ("sc0303", "小王"));  // 创建一个无名pair对象，并插入到map中	
m1.insert(make_pair("sc0303", "小王"));              // 要插入的关键字已在容器中，emplace/insert什么都不做
m1.insert(map<string, string>::value_type("sc0303", "小王"));   // 要插入的关键字已在容器中，emplace/insert什么都不做
m1["sc0304"] = "小何";             // 如果key不存在则插入该键值对，如果key已存在则修改该key对应的value。

m1.emplace(p1);			                             // 要插入的关键字已在容器中，emplace/insert什么都不做
m1.emplace(pair<string, string>("sc0303", "小王"));  // 要插入的关键字已在容器中，emplace/insert什么都不做

1.3.5 删除元素

  1. 删除关键字为key的元素
m1.erase(key)
  1. 删除迭代器iter指向的元素
m1.erase(iter);
  1. 删除迭代器iter1和ter2指向的范围中元素
m1.erase(iter1,iter2);
  1. 删除m1中的所有元素
m1.clear();

m1.erase("sc0301");		  // 删除关键字为"sc0301"的元素
auto iter = m1.begin();   // 指向m2的首元素的迭代器
m1.erase(iter);           // 删除迭代器指向的元素
auto iter1 = m1.begin(), iter2 = m1.end();
m1.erase(iter1, iter2);   // 删除迭代器iter1、iter2指向的范围中的元素
m2.clear();               // 删除容器中的全部元素

1.3.6 map的大小

  1. 获得m1的大小
m1.szie();
  1. 若m1为空返回值为true，否则返回值为false
m1.empty();

int s = m3.size();    // 获得m1的大小
bool e = m3.empty();  // 若m1为空返回值为true，否则返回值为false

1.3.7 查找

通常不对关联容器使用泛型算法。我们可以用泛型find算法来查找map中的元素，但此算法会进行顺序搜索。使用关联容器定义的专用find成员会比调用泛型find快得多

  1. 返回一个迭代器，指向第一个关键字为key的元素，若key不在容器中，则返回尾后迭代器
m1.find(key)
  1. 返回关键字等于key的元素的数量。对于不允许重复关键字的容器map，返回的值是0或1
m1.count(key);
  1. 返回一个迭代器，指向第一个关键字不小于key的元素
m1.lower_bound(key);
  1. 返回一个迭代器，指向第一个关键字大于key的元素
m1.upper_bound(key);

map<string, string>::iterator it = m4.find("sc0301");  // 查找关键字为"sc0301"的元素,返回一个迭代器
if (it == m4.end()) {         // 若"sc0301"不在容器中，则it等于尾后迭代器
	cout << "未找到！" << endl;
}
else {
	pair<string, string> result1 = *it;	// 找到了
}

int result2 = m4.count("sc0305");  // 查找关键字为"sc0301"的元素,返回关键字等于"sc0301"的元素数量
if (result2==0) {
	cout << "未找到！" << endl;
}
else {
	cout << "找到了！" << endl;
}

map<string, string>::iterator it_up = m4.upper_bound("sc0301");  // 返回一个迭代器，指向第一个关键字大于"sc0301"的元素
pair<string, string> result3 = *it_up;

1.3.8 程序示例

#include <iostream>
#include <string>
#include <utility>
#include <map>

using namespace std;

int main() {	
	// 初始化-----------------------------------------------------------------------------------
	pair<string, string> p1("sc0301","小杨");	            // 方式一，创建一个pair名为p1
	pair<string, string> p2 = make_pair("sc0302", "小马");	// 方式二，make_pair函数返回一个用"sc0302"和 "小马"初始化的pair
	pair<string, string> p3("sc0303", "小王");
	pair<string, string> p4("sc0304", "小何");

	map<string, string> m1;                 // 创建一个空map
	map<string, string> m2{ p1,p2,p3,p4 };  // 创建一个包含键值对p1、p2、p3、p4的map
	map<string, string> m3{ {"sc0301","小杨"},{"sc0302", "小马"},{"sc0303", "小王"},{"sc0304", "小何"} }; // 效果同上一句
	map<string, string> m4(m2);   // 创建一个map，m4中包含和m2一样的元素
	map<string, string> m5 = m2;  // 创建一个map，m5中包含和m2一样的元素

	// 访问元素-----------------------------------------------------------------------------------
	string p2_name = m2["sc0302"];	   // 得到学号（关键字）"sc0302"对应的姓名（值）	
	string p3_name = m2.at("sc0303");  // 得到学号"sc0303"对应的姓名	      
	
	map<string, string>::iterator it1 = m2.begin();	 // 得到指向m2首元素的迭代器
	map<string, string>::iterator it2 = m2.end();    // 得到指向m2尾元素的下一个位置的迭代器
	pair<string, string> p11 = *it1;   // 得到m2的首元素{"sc0301","小杨"}
	string p1_ID = it1->first;         // 得到m2的首元素{"sc0301","小杨"}的fisrt成员
	string p1_name = it1->second;	   // 得到m2的首元素{"sc0301","小杨"}的second成员

	// 遍历容器-----------------------------------------------------------------------------------
	for (auto it_b = m2.begin(), it_e = m2.end(); it_b != it_e;++it_b) {
		pair<string, string> current = *it_b;
		cout << "学号：" << it_b->first << "; 姓名:" << it_b->second << endl;
		// 上面这一句等同于下面这一句
		cout << "学号：" << current.first << "; 姓名:" << current.second << endl;
	}

	for (auto p : m2) {
		cout << "学号：" << p.first << "; 姓名:" << p.second << endl;
	}

	// 添加、修改元素-----------------------------------------------------------------------------------
	m1.insert(p1);	                   // 在map中插入已有的pair
	m1.insert({ "sc0302", "小马" });   // 插入键值对{ "sc0302", "小马" }
	m1.insert(pair<string, string> ("sc0303", "小王"));  // 创建一个无名pair对象，并插入到map中	
	m1.insert(make_pair("sc0303", "小王"));              // 要插入的关键字已在容器中，emplace/insert什么都不做
	m1.insert(map<string, string>::value_type("sc0303", "小王"));   // 要插入的关键字已在容器中，emplace/insert什么都不做
	m1["sc0304"] = "小何";             // 如果key不存在则插入该键值对，如果key已存在则修改该key对应的value。

	m1.emplace(p1);			                             // 要插入的关键字已在容器中，emplace/insert什么都不做
	m1.emplace(pair<string, string>("sc0303", "小王"));  // 要插入的关键字已在容器中，emplace/insert什么都不做

	// 删除元素-----------------------------------------------------------------------------------
	m1.erase("sc0301");		  // 删除关键字为"sc0301"的元素
	auto iter = m1.begin();   // 指向m2的首元素的迭代器
	m1.erase(iter);           // 删除迭代器指向的元素
	auto iter1 = m1.begin(), iter2 = m1.end();
	m1.erase(iter1, iter2);   // 删除迭代器iter1、iter2指向的范围中的元素
	m2.clear();               // 删除容器中的全部元素

	// 大小-----------------------------------------------------------------------------------
	int s = m3.size();    // 获得m1的大小
	bool e = m3.empty();  // 若m1为空返回值为true，否则返回值为false

	// 查找-----------------------------------------------------------------------------------
	map<string, string>::iterator it = m4.find("sc0301");  // 查找关键字为"sc0301"的元素,返回一个迭代器
	if (it == m4.end()) {         // 若"sc0301"不在容器中，则it等于尾后迭代器
		cout << "未找到！" << endl;
	}
	else {
		pair<string, string> result1 = *it;	// 找到了
	}

	int result2 = m4.count("sc0305");  // 查找关键字为"sc0301"的元素,返回关键字等于"sc0301"的元素数量
	if (result2==0) {
		cout << "未找到！" << endl;
	}
	else {
		cout << "找到了！" << endl;
	}

	map<string, string>::iterator it_up = m4.upper_bound("sc0301");  // 返回一个迭代器，指向第一个关键字大于"sc0301"的元素
	pair<string, string> result3 = *it_up;
}

3 参考

舒泱——pair
舒泱——unordered_map

孟庆磊
关注
专栏目录
C++ STL学习笔记 : 2. unordered map 容器
Cy_coding的博客
05-05 954
本文中，总结一下使用unordered map 的心得。 首先当然是要include相关库。 # include <unordered_map> 1.定义一个一维的unordered map: unordered_map<uint64_t,string> mymap; unordered_map<uint64_t,uint64_t> mymap2a unord...
LeetCode刷题小结之map、unordered_map的使用
apeapple的博客
02-05 2384
Map 1.特点：map存储key->value键值对，在一个map中仅存在唯一的key。可以实现快速插入、查找、遍历。内部由红黑树实现，所以查找速度上慢于哈希实现的unordered_map，但是元素按照key顺序排列，所以在对顺序有要求的问题中可以使用map。 2.常用方法： #include #include #include #include using namespac
STL—unordered_map 哈希表
weixin_40535588的博客
05-04 2603
参考：https://blog.csdn.net/hk2291976/article/details/51037095 1.介绍 最近使用到一个c++的容器——unordered_map，它是一个关联容器，内部采用的是hash表结构，拥有快速检索的功能。 1.1 特性 关联性：通过key去检索value，而不是通过绝对地址（和顺序容器不同） 无序性：使用hash表存储，内部无序 M...
＜unordered_map＞的first、second
lichengyang的博客
11-12 480
【代码】＜unordered_map＞的first、second。
C++ STL unordered_map
m0_49490139的博客
03-15 321
unordered_map1 特性2 迭代器3 函数 1 特性 unordered_map是C++的一个容器（关联容器），其内部采用hash表的结构，可以快速检索。 映射（map）： 键值对（key value）一一对应。 无序（unordered）： hash表存储，内部无序。 关联： 通过key检索value，时间复杂度为O(1)。 唯一： 每个元素的key都唯一存在。 2 迭代器 unordered_map的迭代器可以指向容器中的某一元素，并通过first和second获得该元素的key和v
C++中的unordered_map用法详解
asdfadafd的博客
08-14 2580
unordered_map是一个将key和value关联起来的容器，它可以高效的根据单个key值查找对应的value。key值应该是唯一的，key和value的数据类型可以不相同。unordered_map存储元素时是没有顺序的，只是根据key的哈希值，将元素存在指定位置，所以根据key查找单个value时非常高效，平均可以在常数时间内完成。unordered_map查询单个key的时候效率比map高，但是要查询某一范围内的key值时比map效率低。...
记录下map 和unordered_map的用法
I-am-Unique
09-14 655
                                    “ 多做善事才是好运的根本！”   2018年9月14日 8月、9月、10月~ 挺过去，一切都会好的， 但是竭尽全力， 因为，你后悔不起~   记录下C++、数据结构中的一些知识用法吧： 我们都知道，容器是存放数据的地方，常见的容器有序列式容器和关联式容器，序列式容器，即其中的元素不一定有序，但可以被排序，比...
嵌入式秋招八股文笔记——数据结构和算法
I_LOVE_STM32的博客
09-02 1178
二分查找是一种在每次比较之后将查找空间一分为二的算法。每次需要查找集合中的索引或元素时，都应该考虑二分查找。如果集合是无序的，我们可以总是在应用二分查找之前先对其进行排序。tips：1.二分查找中，如果数组长度为偶数，则判断的是中间偏左的那个数的值。1.回溯算法属于一种暴力搜索法，一般用于多层for循环搜索复杂度太高的情况。2.pop是没有返回值的，如果想读取栈顶元素得用top。1.栈中的数据元素遵守“先进后出"原则。2.二分查找的时间复杂度为（log2n）力扣77题 数组的子组合。
《B站-青岛大学-王卓老师-数据结构与算法基础》自学心得、笔记（C++语言实现）.zip
最新发布
06-17
在《B站-青岛大学-王卓老师-数据结构与算法基础》的自学过程中，笔记和心得的整理至关重要，它们可以帮助你巩固所学知识，提高解决问题的能力。ljg_resource1可能是其中的资源文件，可能包含了代码示例、习题解答或...
《数据结构——C++实现》（第二版）课本源代码.zip
06-16
7. **排序与查找算法**：排序如快速排序、归并排序、堆排序等，查找如二分查找、哈希查找等，都是数据结构中的关键概念。 8. **哈希表**：通过哈希函数将数据映射到固定大小的数组，实现快速查找。C++标准库中的`...
关于数据结构与算法相关实例Demo.zip
06-17
本压缩包"关于数据结构与算法相关实例Demo.zip"包含了针对C/C++/JAVA/Python等编程语言的数据结构学习笔记和相关资料，为大学生提供了一个全面的学习资源库。 在C/C++、JAVA和Python中，数据结构主要涉及以下几种...
【笔记】哈希表
ericma12的博客
12-09 473
本系列总计六篇文章，是 [基于STL实现的笔试题常考七大基本数据结构] 该文章在《代码随想录》和《labuladong的算法笔记》题目中的具体实践，每篇的布局是这样的：开头是该数据结构的总结，然后是在不同场景的应用，以及不同的算法技巧。本文是系列第三篇，介绍了哈希表的相关题目，重点是要掌握STL的set和map，注意N数之和问题，用双指针最方便。
C++STL之map和unordered_map详解
zdlzf的博客
07-06 3002
前面的STL的容器，如vector、list、deque等都是，因为（1）底层的数据结构是线性的（2）存储的是元素本身（3）数据和数据之间没有关联也是用来存储数据的， 不过里面存储的是键值对，数据检索时，效率比序列式容器高。STL有两种关联式容器：树形结构和哈希结构。树形结构的关联式容器有4种：set、map 、multiset、multimap，它们的底层都是平衡搜索树（红黑树）。
c++11 标准库关联容器 map unordered_map
Li03
09-29 561
输入： 一段字符，结束符号为q。 输出： 出现次数最多，如果有多个，就一起输出，用空格隔开。 分析： 这种用map处理最简洁，key是输入的字符，value是字符的次数，寻找最大的数，然后遍历map，判断map的second参数是不是max，是就输出map的第一个参数。因为是多个string注意用auto类型表示迭代器it的类型，或者写<map<string,int>::iterator> it #include<iostream> #include&lt.
【c++】STL 容器 unordered_map用法详解
青春不言败
05-26 1万+
这里对unordered_map进行一些简单的介绍，包括其基本用法。更加详细的介绍请学习cplusplus网站相关资料。1 一、定义 template < class Key, // unordered_map::key_type class T, ...
C++ 中unordered_map的用法
热门推荐
snailme的博客
05-05 6万+
cplusplus c++使用unordered_map #include&lt;tr1/unordered_map&gt;//在unordered_map之前加上tr1库名， using namespace std::tr1;//与此同时需要加上命名空间 [查找元素是否存在] 若有unordered_map &lt;int, int&gt; mp;查找x是否在m...
关联容器（五）：unordered_map
ceasadan的博客
12-12 4671
介绍： 哈希map是一种关联容器，通过键值和映射值存储元素。允许根据键值快速检索各个元素。 在内部unordered_map的元素不以键值或映射的元素作任何特定的顺序排序，其存储位置取决于哈希值,unordered_map容器比map容器更快地通过键值访问他们的单个元素(hash表的思想，以空间换时间),类似下图： （键，值）对是插入的数据； 索引即对应桶（Bucket）； 哈希
C++中unordered_map和map的基本用法（还需补充）
Myblog
08-20 430
参考地址： https://blog.csdn.net/jingyi130705008/article/details/82633778?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162942465016780366592347%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=16294246501678036
unordered_map与unordered_set
08-12
它们的底层实现方式不同，unordered_map使用哈希表作为底层数据结构，而unordered_set也是使用哈希表。unordered_map和unordered_set的区别在于它们存储的类型不同，即unordered_map存储键值对，而unordered_set存储...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值