C++中“map和set”相关内容整理分析

最新推荐文章于 2024-04-15 20:23:24 发布
最新推荐文章于 2024-04-15 20:23:24 发布
阅读量240 收藏 9
点赞数 11
分类专栏： C++日常笔记 文章标签： c++ 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sakeww/article/details/125007707
版权

目录

1. 关联式容器

STL将自己的数据结构分为六大组件，
容器分为：
序列式容器：vector list …
类似于数据结构中的线性表，数据和数据之间没有关联，为了单纯的存储数据，

关联式容器：map和set…
底层是：平衡搜索树，数据和数据之间具有强烈的关系

2. 键值对

3. 树形结构的关联式容器

4. set 和 map简单使用：

set简单使用

insert

#include<set>
#include<iostream>
using namespace std;
void test_set1()
{
	set<int> s;
	s.insert(1);
	s.insert(5);
	s.insert(3);
	s.insert(4);
	s.insert(2);
	s.insert(2);

	set<int>::iterator it = s.begin();
	while (it != s.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;

	auto it1 = s.begin();
	for (auto it1 : s)
	{
		cout << it1 << " ";
	}
	cout << endl;
}
int main()
{
	test_set1();
	return 0;
}

1 2 3 4 5
1 2 3 4 5
所以走的是中序
因为没有重复，所以排序+去重

erase

在这里插入图片描述

#include<set>
#include<iostream>
using namespace std;
void test_set1()
{
	set<int> s;
	s.insert(1);
	s.insert(5);
	s.insert(3);
	s.insert(4);
	s.insert(2);
	s.insert(2);

	set<int>::iterator it = s.begin();
	while (it != s.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;

	set<int>::iterator pos = s.find(2);
	//当没有找到这个值的时候，还要删除，就会报错
	if (pos != s.end()) {
		//pos必须是一个有效位置的迭代器
		s.erase(pos);
	}
	//直接使用值也是可以的
	//找到就删除，没有找到就直接返回
	s.erase(3);
	s.erase(30);

	auto it1 = s.begin();
	for (auto it1 : s){
		cout << it1 << " ";
	}
	cout << endl;
}
int main()
{
	test_set1();
	return 0;
}

vs multiset

set是排序+去重
multiset是排序
multi：多种

find

void test(){
	multiset<int> s;
	s.insert(2);
	s.insert(1);
	s.insert(5);
	s.insert(2);
	s.insert(3);
	s.insert(4);
	s.insert(2);
	s.insert(2);

	//找到的是那个2？
	//multiset<int>::iterator pos = s.find(2);
	auto pos = s.find(2);
	while (pos != s.end())
	{
		cout << *pos << " ";
		++pos;
	}
	cout << endl;
}
//2 2 2 2 3 4 5
//中序的第一个一，不一定是叶子
int main()
{
	test();
	return 0;
}

erase

void test() {
	multiset<int> s;
	s.insert(2);
	s.insert(1);
	s.insert(5);
	s.insert(2);
	s.insert(3);
	s.insert(4);
	s.insert(2);
	s.insert(2);

	auto pos = s.find(2);
	//方式一：
	//while (pos != s.end() && *pos==2)
	//{
	//	auto newpos = pos;
	//	newpos++;
	//	s.erase(pos);
	//	pos = newpos;
	//}
	
	//方式二：
	cout << s.erase(2) << endl;
	//4
	//1 3 4 5

	multiset<int>::iterator it1 = s.begin();
	for (auto it1 : s) {
		cout << it1 << " ";
	}
	cout << endl;
}
int main()
{
	test();
	return 0;
}

map的简单使用

insert

在这里插入图片描述

void test1()
{
	map<string, string> dict;
	pair<string, string> kv1("红色", "red");
	dict.insert(kv1);
	dict.insert(pair<string, string>("蓝色","blue"));
	//自动推导类型
	dict.insert(make_pair("黄色", "yellow"));//推荐
	dict.insert({"苹果","apple"});//C++11语法

	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		cout << (*it).first << " " << (*it).second << endl;
		cout << it->first << " " << it->second << endl;
		++it;
	}
	cout << endl;

	for (auto& kv : dict)
	{
		cout << kv.first << " " << kv.second << endl;
	}
}

int main()
{
	test1();
	return 0;
}

operator[]

void test()
{
	string arr[] = { "苹果","香蕉", "苹果", "梨", "苹果", "苹果" };
	map<string, int> countMap;
	//first
	//for (auto& str : arr)
	//{
	//	auto ret = countMap.find(str);
	//	if (ret == countMap.end())//没有找到
	//	{
	//		countMap.insert(make_pair(str, 1));
	//	}
	//	else {
	//		ret->second++;
	//	}
	//}
	//second
	//for (auto& str : arr)
	//{
	//	auto kv = countMap.insert(make_pair(str, 1));
	//	if (kv.second==false) {
	//		kv.first->second++;
	//	}
	//}
	//third
	for (auto& str : arr){
		countMap[str]++;
	}
	for (auto& kv : countMap){
		cout << kv.first << " " << kv.second << endl;
	}
}

在这里插入图片描述
operator[]功能：
1.插入
2.查找（key 对应的 value）
3.修改（key 对应的 value）

void test()
{
	map<string, string> dict;
	dict.insert(make_pair("right", "右边"));
	dict.insert(make_pair("left", "左边"));
	dict.insert(make_pair("left", "中间"));//插入，但是不成功

	dict["left"] = "做边";//修改，成功
	dict["test"];//插入，test对应的value=""
	dict["right"];
	cout << dict["mid"] << endl;//先插入，然后在输出""
}
int main()
{
	test();
	return 0;
}

multimap

void test()
{
	multimap<string, string> dict;
	dict.insert(make_pair("left", "左边"));
	dict.insert(make_pair("left", "左边"));
	dict.insert(make_pair("left", "中间"));
	dict.insert(make_pair("right", "右边"));
	for (auto& kv : dict) {
		cout << kv.first << " " << kv.second << endl;
	}
}
//left 左边
//left 左边
//left 中间
//right 右边
int main()
{
	test();
	return 0;
}

延伸：
multimap没有[]
查找也是第一个

5. set和map相关题

1.map关于second的排序

一vector

struct CountVal
{
	bool operator()(const pair<string, int>& left,const pair<string,int>& right)
	{
		return left.second > right.second;
	}

};
void GetFavoriteFruit(const vector<string>& fruits, size_t k)
{
	map<string, int> countMap;
	for (auto& str : fruits)
	{
		countMap[str]++;
	}

	//1.数据量不大，排序
	vector<pair<string, int>> sortV;
	for (auto& kv : countMap)
	{
		sortV.push_back(kv);
	}
	sort(sortV.begin(), sortV.end(), CountVal());
	
	for (int i = 0; i < k; i++)
	{
		cout << sortV[i].first << ":" << sortV[i].second << endl;
	}
}
int main()
{
	vector<string> arr = { "苹果","香蕉", "苹果", "梨", "杏", "苹果",
		"苹果","香蕉", "桃", "梨", "苹果", "苹果" };
	GetFavoriteFruit(arr, 3);
	return 0;
}

二vector+迭代器

struct CountInterVal
{
	bool operator()(const map<string, int>::iterator& left, const map<string, int>::iterator& right) {
		return left->second > right->second;
	}
};
void GetFavoriteFruit(const vector<string>& fruits, size_t k)
{
	map<string, int> countMap;
	for (auto& str : fruits)
		countMap[str]++;

	vector<map<string, int>::iterator> sortV;
	auto it = countMap.begin();
	while (it != countMap.end()){
		sortV.push_back(it);
		++it;
	}
	sort(sortV.begin(), sortV.end(), CountInterVal());

	for (int i = 0; i < k; i++)
		cout << sortV[i]->first << ":" << sortV[i]->second << endl;
}
int main()
{
	vector<string> arr = { "苹果","香蕉", "苹果", "梨", "杏", "苹果",
		"苹果","香蕉", "桃", "梨", "苹果", "苹果" };
	GetFavoriteFruit(arr, 3);
	return 0;
}

三multimap+迭代器

struct CountInterVal
{
	bool operator()(const map<string, int>::iterator& left, const map<string, int>::iterator& right) {
		return left->second > right->second;
	}
};
void GetFavoriteFruit(const vector<string>& fruits, size_t k)
{
	map<string, int> countMap;
	for (auto& str : fruits)
		countMap[str]++;
	multimap<int,string,greater<int>> sortMap;
	for (auto& kv : countMap) {
		sortMap.insert(make_pair(kv.second,kv.first));
	}
}
int main()
{
	vector<string> arr = { "苹果","香蕉", "苹果", "梨", "杏", "苹果",
		"苹果","香蕉", "桃", "梨", "苹果", "苹果" };
	GetFavoriteFruit(arr, 3);
	return 0;
}

四优先级队列

struct CountVal
{
	bool operator()(const pair<string, int>& left, const pair<string, int>& right)
	{
		return left.second < right.second;
	}
};
void GetFavoriteFruit(const vector<string>& fruits, size_t k)
{
	map<string, int> countMap;
	for (auto& str : fruits)
		countMap[str]++;
	
	priority_queue<pair<string, int>, vector<pair<string, int>>, CountVal> pq;
	for (auto& kv : countMap) {
		pq.push(kv);
	}
	while (k--) {
		cout << pq.top().first << pq.top().second << endl;
		pq.pop();
	}
}
int main()
{
	vector<string> arr = { "苹果","香蕉", "苹果", "梨", "杏", "苹果",
		"苹果","香蕉", "桃", "梨", "苹果", "苹果" };
	GetFavoriteFruit(arr, 3);
	return 0;
}

五优先级队列+迭代器

struct CountIterVal
{
	bool operator()(const map<string, int>::iterator& left, const map<string, int>::iterator& right) {
		return left->second < right->second;
	}
};
void GetFavoriteFruit(const vector<string>& fruits, size_t k)
{
	map<string, int> countMap;
	for (auto& str : fruits)
		countMap[str]++;

	priority_queue<map<string, int>::iterator, vector<map<string, int>::iterator>, CountIterVal> pq;
	auto it = countMap.begin();
	while (it != countMap.end()){
		pq.push(it);
		++it;
	}

	while (k--){
		cout << pq.top()->first << ":" << pq.top()->second << endl;
		pq.pop();
	}
	cout << endl;
}
int main()
{
	vector<string> arr = { "苹果","香蕉", "苹果", "梨", "杏", "苹果",
		"苹果","香蕉", "桃", "梨", "苹果", "苹果" };
	GetFavoriteFruit(arr, 3);
	return 0;
}

2.前K个高频单词

链接: 前K个高频单词
在这里插入图片描述

class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
    map<string,int> CountMap;
    for(auto& str:words) CountMap[str]++;

    multimap<int,string,greater<int>> sortMap;
    for(auto& kv:CountMap)
        sortMap.insert(make_pair(kv.second,kv.first));
    vector<string> v;
    auto it = sortMap.begin();
    while(k--){
        v.push_back(it->second);
        ++it;
    }
    return v;
    }
};

4. 底层结构

4.1AVL树/高度平衡二叉搜索树

概念：
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下
当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
它的左右子树都是AVL树
左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
在这里插入图片描述
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在O( log2n) ，搜索时间复杂度O( log2n)。

4.2简单模拟实现链接：

链接: C++中“AVL”树的模拟实现以及实现中遇见的问题

4.3红黑树

概念：

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的
在这里插入图片描述

性质：

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的（说明：树中没有连续的红色节点）
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点（说明：每条路径黑色节点的数量相等）
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

在这里插入图片描述

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

最短路径：全黑
最长路径：一黑一红

假设每条路径黑节点的数量是：N
N <= 任意路径长度 <= 2N

底层简单模拟实现，以及实现中遇见的问题

https://blog.csdn.net/sakeww/article/details/125036961

sakeww
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
map和set的异同
09-28
map和set的异同map和set的异同map和set的异同map和set的异同
C++——关联式容器map和set
qq_44745063的博客
10-09 255
作者：小琛 欢迎转载，请标明出处 关联式容器的意义 关联式容器 vector、list、deque，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。 关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对(下面会进行解释)， 总结来说就是：之前的容器就像是一个普通的瓶子，里面存放的就是元素本身。而关联式容器就是带标签的瓶子，根据标签来找元素，而标签也是该瓶子的一部分。 例如英语字典，一个元素都有英文和中文，英文和
C++_map与set
安权_code的博客
03-01 1034
C++中的map和set容器属于关联式容器，与序列式容器不同的地方在于（序列式容器即vector、list，其底层是由线性数据结构实现的容器），关联式容器存储的是键值对，键值对是一个结构体，他只有两个成员变量：key,value，并且key和value是一一对应的，key表示键值，而value就是key对应的数据。
C++ map和set
m0_61548909的博客
08-12 1182
问题：当key不在map中时，通过operator获取对应value时会发生什么问题？注意：在元素访问时，有一个与operator[]类似的操作at()(该函数不常用)函数，都是通过key找到与key对应的value。
【C++】set和map
m0_62179366的博客
11-06 7312
map与set也十分的相似，map是K/V的模型，set是K的模型map也有两种区别与set和multiset相同，只是键值是否允许冗余的差别不过map的插入就比较特别了我们发现insert的参数是一个value_type类型然后我们发现它实际上是一个pair{T1 first;T2 second;{}{}};用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。
map和set的模拟实现
最新发布
06-06
它们在C++标准库中被广泛使用，提供了高效的键值对存储（Map）和唯一元素存储（Set）功能。本文将深入探讨如何通过封装红黑树来模拟实现Map和Set。 红黑树是一种自平衡二叉查找树，它的主要特性是每个节点都带有...
c++容器list、vector、map、set区别与用法详解
08-19
c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 list容器 list容器是一个双向链表，链表的每个...
c++关联容器用法详解（set与map）
01-27
C++中的关联容器是STL（Standard Template Library）的一部分，它们包括了set和map等容器。这些容器的主要特点是它们的元素不是按照它们在容器中的位置排序，而是通过一个关键字（key）来组织和访问，提供了高效的...
C++中vector和map的删除方法(推荐)
01-01
1.连续内存序列容器(vector,string,deque) 序列容器的erase方法返回值是指向紧接在被删除元素之后的元素...2.关联容器(set,multiset,map,multimap) 关联容器的erase方法没有返回值，被删除的迭代器失效，所以删除前必须
C++ - set 和 map详解
大海洋的博客
04-15 2584
详细介绍了 set 以及 map.
C++STL中的set容器和map容器
yang_zongjun的专栏
09-04 3326
set之存储了一个键值， 而mapcunchu
C++中关联容器map和set使用说明
zhangjikuan的专栏
10-25 2758
C++中关联容器map和set使用说明 一：map C++中map容器提供一个键值对容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。   (所以map关键字独一无二，重复插入不做操作) 一、map的说明     1   头文件    #include          2   定义    map   my_Map; //第一个string是k
c++如何往map<string, set<string> > 添加数据
黎明前的沉睡
01-30 3177
原文见链接：c++如何往map 添加数据
C++学习笔记13 STL Set和Map
JackZhangNJU的专栏
09-08 300
Set是一种关联容器，它用于存储数据，并且能从一个数据集合中取出数据。它的每个元素的值必须唯一，而且系统会根据该值来自动将数据排序。每个元素的值不能直接被改变。内部结构采用红黑树的平衡二叉树。multiset 跟set 类似，唯一的区别是允许键值重复！为何map和set的插入删除效率比用其他序列容器高？ 因为对于关联容器来说，不需要做内存拷贝和内存移动。map和set容器内所有元素都是以节点的方式来
c++中set与map用法详解
糖葫芦君的博客
01-03 6726
关于STL c++ STL之所以得到广泛赞誉，也被很多人使用，不只是提供了向vector，string，list等方便的容器，更重要的是STL封装了许多复杂的数据结构算法和常用的数据结构操作。vector封装了数组，list封装了链表，map和set封装了二叉树等。在封装这些数据结构的时候，STL按照程序员的使用习惯，以成员函数方式提供了常用操作，如：插入，排序，删除，查找等。 1.set和map...
C++中STL容器的分类和基本功能（二）：集合(set) 映射(map)
一个一般人发现不了的博客
02-03 707
关联容器 特点： 每个关联容器都有一个键(key) 每个元素按键的取值升序排列（对于一个关联容器，使用迭代器s在区间[s.begin(), s.end())内遍历，访问到的序列总是升序） 优势： 可以根据键值高效地查找元素 要求：键值的类型必须能够用 int、double等基本数据类型 其他重载了 例：学生表的存储 class Student{...};
中级C++：set、map的使用
FamerSaul的博客
06-21 305
树形关联式容器 set、map的多种使用方法
C++中map和set的区别
05-24
在C++中，map和set都是STL（标准模板库）中的容器。 map是一种关联容器，它将键值与数据关联起来。map中每个元素都是一个键值对（key-value pair），其中每个键只能出现一次。因此，map中的键是唯一的。在map中，...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值