【C++】20：set和map的理解和使用

原创 已于 2025-12-22 19:52:52 修改 · 404 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2025-12-22 19:52:51 首次发布

目录

一、序列式容器和关联式容器

二、set的使用

2.1 set和multiset的参考文档

2.2 set类的介绍

2.3 set的构造函数和迭代器

2.3.1 默认构造

2.3.2 迭代器区间构造

2.3.3 拷贝构造

2.3.4 initializer构造

2.3.5 迭代器

2.3.6 迭代器的使用

2.4 set的增删

2.4.1 insert()函数

2.4.1.1 单个元素插入

2.4.1.2 迭代器区间插入

2.4.1.3 initializer插入

2.4.2 erase()函数

2.4.2.1 删除迭代器位置的元素

2.4.2.2 删除值为val的元素

2.4.2.3 删除迭代器区间的元素

2.5 find的使用

2.6 count函数的使用

2.7 multiset和set的差异

2.8 两个数组的交集-力扣（LeetCode）

2.9 142.环形链表Il-力扣（LeetCode）

三、map的使用

3.1 map和multimap参考文档

3.2  map类的介绍

3.3 pair类型介绍

3.4 map的插入函数insert

3.5 map的遍历

3.5.1 迭代器方式

3.5.2 范围for

3.6 map的构造函数

3.6.1 空初始化

3.6.2 拷贝构造

3.6.3 使用initializer初始化

3.7 map的删除函数erase

3.8 map的查找函数find

3.9 map的数据修改和[]  (非常重要)

3.10 multimap和map的差异

3.11 138.随机链表的复制-力扣（LeetCode）

3.11.1 不使用map的方法

3.11.2 使用map的方法

3.12 692.前K个高频单词-力扣（LeetCode）

一、序列式容器和关联式容器

前面我们已经接触过STL中的部分容器如：string、vector、list、deque、array、forward_list等，这些容器统称为序列式容器，因为逻辑结构为线性序列的数据结构，两个位置存储的值之间一般没有紧密的关联关系，比如交换一下，他依旧是序列式容器。顺序容器中的元素是按他们在容器中的存储位置来顺序保存和访问的。

关联式容器也是用来存储数据的，与序列式容器不同的是，关联式容器逻辑结构通常是非线性结构，两个位置有紧密的关联关系，交换一下，他的存储结构就被破坏了。顺序容器中的元素是按关键字来保存和访问的。关联式容器有map/set系列和unordered_map/unordered_set系列。

本章节讲解的map和set底层是红黑树，红黑树是一颗平衡二叉搜索树。set是key搜索场景的结构，map是key/value搜索场景的结构。

二、set的使用

使用set需要包set头文件

2.1 set和multiset的参考文档

<set> - C++ Reference

2.2 set类的介绍

  • set的声明如下，T就是set底层关键字的类型

  • set默认要求T支持小于比较，如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模版参数
  • set底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给第三个参数。
  • 一般情况下，我们都不需要传后两个模版参数。
  • set底层是用红黑树实现，增删查效率是O(logN），迭代器遍历是走的搜索树的中序，所以是有序的。
  • 前面部分我们已经学习了vector/list等容器的使用，STL容器接口设计，高度相似，所以这里我们就不再一个接口一个接口的介绍，而是直接带着大家看文档，挑比较重要的接口进行介绍。

2.3 set的构造函数和迭代器

set的构造函数如下所示：

现在我们常用的就是1，2，3，5种

2.3.1 默认构造

默认构造就是不需要传入参数的构造，如下所示：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1;
	return 0;
}

2.3.2 迭代器区间构造

迭代器区间构造就是传入两个迭代器，然后就迭代器区间的内容拷贝到set里面，如下所示：

#include<iostream>
using namespace std;
#include<set>
#include<vector>
int main()
{
	vector<int> v1 = { 4,3,2,1,6,7};
	set<int> s1(v1.begin(),v1.end());
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

2.3.3 拷贝构造

拷贝构造就是使用一个已经存在的set来初始化另外一个set，如下所示：

#include<iostream>
using namespace std;
#include<set>
#include<vector>
int main()
{
	vector<int> v1 = { 4,3,2,1,6,7};
	set<int> s1(v1.begin(),v1.end());
	set<int> s2(s1);
	for (auto& ch : s2)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

2.3.4 initializer构造

initializer构造就是可以使用一个大括号来初始化set，如下所示：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7});  //直接调用构造
	set<int> s2={ 4,3,2,1,6,7};  //隐身类型转换
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	for (auto& ch : s2)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

2.3.5 迭代器

set的迭代器是一个双向迭代器，支持++和--；但是不支持+和-；

// 正向迭代器
iterator begin ();
iterator end ();
// 反向迭代器
reverse_iterator rbegin ();
reverse_iterator rend ();

2.3.6 迭代器的使用

我们使用迭代器来遍历set容器，如下所示：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });  
	set<int>::iterator sit = s1.begin();
	while (sit != s1.end())
	{
		cout << *sit << " ";
		sit++;
	}
	cout << endl;
	return 0;
}

只有支持迭代器，就能够支持范围for，因为范围for的底层结构就是迭代器，如下所示：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });  
	set<int>::iterator sit = s1.begin();
	/*while (sit != s1.end())
	{
		cout << *sit << " ";
		sit++;
	}
	cout << endl;*/
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

2.4 set的增删

在set容器种，是支持增删查的，但是不允许修改，因为修改会改变底层二叉树的结构，所以不支持修改。

2.4.1 insert()函数

insert函数的原型如下：

它支持插入单个元素，插入一个迭代器区间，和initializer插入。

insert在插入set里面已有的元素时，不会报错，但是也不会插入这个已经有的元素。

2.4.1.1 单个元素插入

代码如下：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });  //直接调用构造
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	s1.insert(50);
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

单个元素的插入会返回一个pair类型的对象，这个对象有两个元素，第一个元素是插入元素的迭代器，第二个元素是一个bool类型，表示是否插入成功。pair类型在下面讲map的时候讲解。

2.4.1.2 迭代器区间插入
#include<iostream>
using namespace std;
#include<set>
int main()
{
	int array[] = { 10,20,30,40,0 };
	set<int> s1({ 4,3,2,1,6,7});  //直接调用构造
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	s1.insert(array,array+5);
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}
2.4.1.3 initializer插入
#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });  //直接调用构造
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	s1.insert({ 10,20,0, 70,100 });
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

2.4.2 erase()函数

erase函数原型如下：

它支持删除一个迭代器位置的元素，支持删除一个元素，也支持删除一个迭代器区间的元素

2.4.2.1 删除迭代器位置的元素

他经常搭配find函数一起使用，代码如下：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });
	set<int>::iterator sit = s1.begin();
	sit++;  //指向中序遍历的第二个元素
	s1.erase(sit); //删除第二个元素
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}
2.4.2.2 删除值为val的元素
#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });
	s1.erase(100);  //支持删除不存在的元素，不会报错，返回值是0
	s1.erase(1);  //返回值是1，erase函数的返回值是删除val元素的个数

	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

在set里面erase的返回值是0或者1，如果要删除的元素不存在，返回值就是0；如果要删除的元素存在，返回值就是1；在multiset里面会存在返回值大于1的场景，因为multiset里面可以有相同的元素，set里面不允许相同的元素。

2.4.2.3 删除迭代器区间的元素
#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });
	cout << "删除前：" << endl;
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	set<int>::iterator bit = s1.begin();
	set<int>::iterator eit = s1.end();
	bit++;
	eit--;
	s1.erase(bit, eit); //删除第二个位置和倒数第二个位置之间的元素，不包括倒数第二个，这里的位置是中序的位置
	cout << "删除后：" << endl;
	for (auto& ch : s1)
	{
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

2.5 find的使用

find的函数原型如下：

在set里面查找val，如果val存在就返回这个位置的迭代器，如果不存在就返回set.end();

代码如下：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });
	set<int>::iterator sit = s1.find(3);
	if (sit != s1.end())
	{
		cout << "找到了！" << endl;
	}
	else 
	{
		cout << "找不到！" << endl;
	}
	set<int>::iterator sit1 = s1.find(100);
	if (sit == s1.end())
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "找不到！" << endl;
	}
	return 0;
}

2.6 count函数的使用

count函数原型如下：

这个函数的作用是统计set中val的个数，在set里面会返回0或者1，但是在multiset容器会返回大于1的值，因为multiset支持元素重复。代码如下：

#include<iostream>
using namespace std;
#include<set>
int main()
{
	set<int> s1({ 4,3,2,1,6,7 });
	cout << s1.count(2) << endl;
	multiset<int> s2({ 4,3,2,1,6,7,3,3,3,3,3 });
	cout << s2.count(3) << endl;
	return 0;
}

2.7 multiset和set的差异

multiset和set的使用基本完全类似，主要区别点在于multiset支持值冗余，
insert/find/count/erase都围绕着支持值冗余有所差异，具体参看下面的样例代码理解。

#include<iostream>
#include<set>
using namespace std;
int main()
{
// 相⽐set不同的是，multiset是排序，但是不去重
multiset<int> s = { 4,2,7,2,4,8,4,5,4,9 };
auto it = s.begin();
while (it != s.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// 相⽐set不同的是，x可能会存在多个，find查找中序的第⼀个
int x;
cin >> x;
auto pos = s.find(x);
while (pos != s.end() && *pos == x)
{
cout << *pos << " ";
++pos;
}
cout << endl;
// 相⽐set不同的是，count会返回x的实际个数
cout << s.count(x) << endl;
// 相⽐set不同的是，erase给值时会删除所有的x
s.erase(x);
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
return 0;
}

2.8 两个数组的交集-力扣（LeetCode）

链接如下：349. 两个数组的交集 - 力扣（LeetCode）

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> s1(nums1.begin(),nums1.end());
        set<int> s2(nums2.begin(),nums2.end());
        vector<int> v;
        set<int>::iterator it1=s1.begin();
        set<int>::iterator it2=s2.begin();
        while(it1!=s1.end()&&it2!=s2.end())
        {
            if(*it1<*it2)
            {
                it1++;
            }else if(*it1>*it2)
            {
                it2++;
            }else{
                v.push_back(*it1);
                it1++;
                it2++;
            }
        }
        return v;
    }
};

2.9 142.环形链表Il-力扣（LeetCode）

链接如下：142. 环形链表 II - 力扣（LeetCode）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        set<ListNode*> s1;
        ListNode* cur=head;
        while(cur!=nullptr)
        {
            if(s1.count(cur)==0)
            {
                s1.insert(cur);
                cur=cur->next;
            }else{
                return cur;
            }
        }
        return nullptr;
    }
};

三、map的使用

使用map需要包map头文件

3.1 map和multimap参考文档

<map> - C++ Reference

3.2  map类的介绍

map的声明如下，Key就是map底层关键字的类型T是map底层value的类型，set默认要求Key支持小于比较，如果不支持或者需要的话可以自行实现仿函数传给第二个模版参数，map底层存储数据的内存是从空间配置器申请的。一般情况下，我们都不需要传后两个模版参数。map底层是用红黑树实现，增删查改效率是O(logN)，迭代器遍历是走的中序，所以是按key有序顺序遍历的。

3.3 pair类型介绍

我们再文档里面查看insert插入的数据类型，如下所示：

它插入的数据类型是value_type类型的数据，然后我们再在文档里面查看这个类型是谁typedef出来的，如下所示：

可以看到value_type是一个pair类型的数据，pair里面的类型是Key类型和T类型。

也就是说，在map里面都是把key和value整合成一个类型存放的，而不是单独存放的。

那pair是什么呢？如下所示：

底层代码如下所示：

template <class T1, class T2>
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;
	T1 first;
	T2 second;
	pair() : first(T1()), second(T2())
	{
	}
	pair(const T1& a, const T2& b) : first(a), second(b)
	{
	}
	template<class U, class V>
	pair(const pair<U, V>& pr) : first(pr.first), second(pr.second)
	{
	}
};

3.4 map的插入函数insert

我们在上面说过，map插入的数据类型是pair类型的数据，下面讲解插入的4种方式

方式一：定义一个有名的pair对象，然后将这个pair对象插入，代码如下：

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	pair<string, string> kv1("first", "第一个");
	dict.insert(kv1);
	return 0;
}

方式二：插入一个匿名的pair对象，如下所示：

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	dict.insert(pair<string,string>("first", "第一个"));
	return 0;
}

方式三：调用一个make_pair的函数，创建一个pair，如下所示：

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	dict.insert(make_pair("first", "第一个"));
	return 0;
}

make_pair是一个函数模板，它返回一个pair对象。

方式四：使用隐式类型转换，会将initializer转换为pair类型，如下所示：

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	dict.insert({ "first", "第一个" });
	return 0;
}

插入的时候只关注key相不相等，跟value相不相等没有关系。如下所示：

map<string, string> dict;
dict.insert({ "first", "第一个" });

dict.insert({ "first", "第一个1111" });    //这个会插入失败

我们使用insert函数插入一个pair类型的数据时，无论插入成功都会返回一个pair类型的对象，这个pair对象，第二个参数是一个bool类型，插入成功就是true，插入失败就是false（map里面有这个key就会插入失败）。

第一个参数是一个迭代器：

如果插入成功，这个迭代器指向这个这个新插入的元素，

如果插入失败，就说明map里面已经有这个key了，就指向这个元素、

插入成功的话，返回 pair<新插入值所在的迭代器，true>

插入失败的话，返回 pair<已经存在的跟key相等值迭代器，false>

3.5 map的遍历

我们将上面的四种插入方式联系一下，代码如下：

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	pair<string, string> kv1("first", "第一个");
	dict.insert(kv1);
	
	dict.insert(pair<string, string>("auto", "自动的"));

	dict.insert(make_pair("apple", "苹果"));

	dict.insert({ "pear","梨子" });
	return 0;
}

那我们现在应该如何遍历呢？直接解引用这个map类型的迭代器嘛？答案如下：

3.5.1 迭代器方式

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	pair<string, string> kv1("first", "第一个");
	dict.insert(kv1);
	
	dict.insert(pair<string, string>("auto", "自动的"));

	dict.insert(make_pair("apple", "苹果"));

	dict.insert({ "pear","梨子" });

	map<string, string>::iterator dit = dict.begin();
	while (dit != dict.end())
	{
		cout<<(*dit).first<< ":" << (*dit).second << endl;
		cout << dit->first << ":" << dit->second << endl;
		//上面等价于===
		//cout << dit.operator->()->first << ":" << dit.operator->()->second << endl;
		dit++;
	}
	return 0;
}

3.5.2 范围for

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	pair<string, string> kv1("first", "第一个");
	dict.insert(kv1);

	dict.insert(pair<string, string>("auto", "自动的"));

	dict.insert(make_pair("apple", "苹果"));

	dict.insert({ "pear","梨子" });

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

3.6 map的构造函数

map的构造函数原型如下：

我们现在经常使用的是1，3，5这四种

3.6.1 空初始化

代码如下：

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	return 0;
}

3.6.2 拷贝构造

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict;
	map<string, string> dict1(dict);
	return 0;
}

3.6.3 使用initializer初始化

#include<iostream>
using namespace std;
#include<map>

int main()
{
	map<string, string> dict = { {"apple","苹果"},{"pear","梨子"}, {"first","第一"} };
	return 0;
}

3.7 map的删除函数erase

函数原型如下：

erase删除只跟key有关系，跟value无关；

插入的时候更key value有关，查找的时候也只跟key有关系，

erase可以删除指定迭代器位置的元素，

也可以删除对应key的元素，这个key如果在map中存在，就删除，不存在也不会报错。

3.8 map的查找函数find

查找的时候只跟key有关系，根据key来查找。

返回对应元素的迭代器。

3.9 map的数据修改和[]  (非常重要)

现在有一堆水果，让我们来统计水果的个数，代码如下所示：

#include<iostream>
using namespace std;
#include<map>
#include<string>
int main()
{
	string arr[] = { "苹果","西瓜","苹果","西瓜","苹果","苹果","西瓜","苹果","香蕉","苹果","香蕉"};
	map<string, int> countMap;
	for (auto& ele : arr)
	{
		//首先查找这个水果在不在map中，如果在，就让对应的value++；如果不再就插入{水果，1}
		auto ret = countMap.find(ele);
		if (ret == countMap.end())
		{
			countMap.insert({ ele,1 });
		}
		else {
			ret->second++;
		}
	}
	for (auto& ele : countMap)
	{
		cout << ele.first << ":" << ele.second << endl;
	}
	return 0;
}

其实在实践中，map是不喜欢用这种方法来统计次数的。常用的如下所示：

#include<iostream>
using namespace std;
#include<map>
#include<string>
int main()
{
	string arr[] = { "苹果","西瓜","苹果","西瓜","苹果","苹果","西瓜","苹果","香蕉","苹果","香蕉" };
	map<string, int> countMap;
	for (auto& ele : arr)
	{
		countMap[ele]++;
	}
	for (auto& ele : countMap)
	{
		cout << ele.first << ":" << ele.second << endl;
	}
	return 0;
}

我们对比这两段代码，[]是怎么做到统计次数的呢？下面给出详细解释：

之前我们使用[]都是像数组一样去访问，这里的[]其实不再是传统意义上的数组访问的[]了。这里使用[]已经改变了原来[]的意思了。

这里的[]指的是：你给我map里面的key，我返回对应的value的引用，原型如下所示：

这个接口综合了插入+查找+修改。

就是说这个接口有插入，查找，修改的功能，非常强大

它的解释如下：

这个函数的功能就等价于这个函数的功能，但是上面这个函数写的非常复杂，我们在上面讲过insert函数的返回值，如下所示：

insert无论插入是否成功，都会返回一个pair类型的对象，意味着这个insert这个函数不但充当着插入的功能，还充当了查找的功能。

插入失败的情况下，它返回false和已经存在跟key相等值的迭代器，这不就是查找的功能嘛？

总结如下：

我们上面说过[]的实现等价于

下面我们来把这个实现展开，如下所示：

首先，方括号里面给了一个key以后，不管这个key是否存在，就直接插入一个pair键值对，第一个参数是key，第二个参数是调用对应的默认构造函数。

如果这个key不再map之中，就会插入key和mapped_type的默认值，然后返回mapped_type的引用，那我们就可以通过这个引用来修改，所以[]具备了插入和修改的功能。

如果key在map之中，insert就会插入失败，但是insert会返回这个节点的迭代器和false，然后返回mapped_type的引用，那我们就可以通过这个引用来修改，所以[]具备了查找和修改的功能。

现在我们解释上面的代码：

当“苹果”不再map里面，就会插入苹果，然后返回mapped_type的引用，然后通过这个引用修改

（所以[]具备了插入和修改的功能）

当我们第二次插入“苹果”时，苹果已经在map里面了，就会插入失败，然后返回已经存在的元素的mapped_type的引用，然后通过这个引用修改。

（所以[]具备了查找和修改的功能）

我们再举一个例子，如下所示：

#include<iostream>
using namespace std;
#include<map>
#include<string>
int main()
{
	map<string, string> dict;
	dict.insert(make_pair("sort", "排序"));

	//key不存在->插入{"insert",string()}
	dict["insert"];
	//key不存在->插入+修改
	dict["left"] = "左边";

	//key存在->查找+修改
	dict["left"] = "左边,剩余";

	//查找 使用[]来查找，一定要确保这个key在，如果不再的话就会执行插入功能
	cout << dict["left"] << endl;
	//插入 因为right不存在
	cout << dict["right"] << endl;
	//尽量少用[]来查找，只有确定这个key在，才用[]来查找。
	for (auto& ele : dict)
	{
		cout << ele.first << ":" << ele.second << endl;
	}
	return 0;
}

3.10 multimap和map的差异

multimap和map的使用基本完全类似，主要区别点在于multimap支持关键值key冗余

那么insert/find/count/erase都围绕着支持关键值key冗余有所差异，这里跟set和multiset完全一样，比如find时，有多个key，返回中序第一个。

其次就是multimap不支持[]，因为支持key冗余，[]就只能支持插入了，不能支持修改。

3.11 138.随机链表的复制-力扣（LeetCode）

题目链接：138. 随机链表的复制 - 力扣（LeetCode）

数据结构初阶阶段，为了控制随机指针，我们将拷贝结点链接在原节点的后面解决，后面拷贝节点还得解下来链接，非常麻烦。这里我们直接让{原结点，拷贝结点}建立映射关系放到map中，控制随机指针会非常简单方便，这里体现了map在解决一些问题时的价值，完全是降维打击。

3.11.1 不使用map的方法

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==nullptr)
            return nullptr;
        //拷贝节点
        Node* cur=head;
        while(cur)
        {
            Node* newnode=new Node(cur->val);
            newnode->next=cur->next;
            cur->next=newnode;
            cur=cur->next->next;
        }
        //处理random
        cur=head;
        Node* copycur=cur->next;
        while(cur)
        {
            if(cur->random==nullptr)
            {
                copycur->random=nullptr;
            }else
            {
                copycur->random=cur->random->next;
            }
           
            cur=copycur->next;
            if(cur)
                copycur=cur->next;
        }
        //将拷贝的节点剪下来
        cur=head;
        Node* copyhead=cur->next;
        copycur=cur->next;
        while(cur)
        {
            cur->next=copycur->next;
            cur=cur->next;
            if(cur!=nullptr)
            {
                copycur->next=cur->next;
                copycur=copycur->next;
            }else
            {
                copycur->next=nullptr;
            }  
        }
        return copyhead;
        
    }
};

3.11.2 使用map的方法

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==nullptr)
            return nullptr;
        Node* cur=head;
        Node* copyhead=nullptr;
        map<Node*,Node*> mymap;
        Node* pre=nullptr;
        while(cur)
        {
            Node* newnode=new Node(cur->val);
            if(copyhead==nullptr)
            {
                copyhead=newnode;
                pre=copyhead;
            }else
            {
                pre->next=newnode;
                pre=pre->next;
            }
             mymap.insert({cur,newnode});
            cur=cur->next;
           
        }
        cur=head;
        Node* copy=copyhead;
        while(cur)
        {
            if(cur->random==nullptr)
            {
                copy->random=nullptr;
            }else{
                copy->random=mymap[cur->random];
            }
            cur=cur->next;
            copy=copy->next;
        }
        return copyhead;
    }
};

3.12 692.前K个高频单词-力扣（LeetCode）

题目链接：692. 前K个高频单词 - 力扣（LeetCode）

方法一：使用map加稳定排序

struct mycompare{
    bool operator()(const pair<string,int>& kv1,const pair<string,int>& kv2)
    {
        return kv1.second>kv2.second;
    }
};
class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string,int> mymap;
        for(auto& ele:words)
        {
            mymap[ele]++;
        }
        vector<pair<string,int>> myvector(mymap.begin(),mymap.end());
        stable_sort(myvector.begin(),myvector.end(),mycompare());
        int i=0;
        vector<string> ret;
        while(i<k)
        {
            ret.push_back(myvector[i].first);
            i++;
        }
        return ret;
    }
};

方法二：使用map加不稳定排序，然后调整仿函数

struct mycompare{
    bool operator()(const pair<string,int>& kv1,const pair<string,int>& kv2)
    {
        return kv1.second>kv2.second || (kv1.second==kv2.second)&&kv1.first<kv2.first;
    }
};
class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string,int> mymap;
        for(auto& ele:words)
        {
            mymap[ele]++;
        }
        vector<pair<string,int>> myvector(mymap.begin(),mymap.end());
        sort(myvector.begin(),myvector.end(),mycompare());
        int i=0;
        vector<string> ret;
        while(i<k)
        {
            ret.push_back(myvector[i].first);
            i++;
        }
        return ret;
    }
};

方法三：使用优先级队列

struct mycompare{
    bool operator()(const pair<string,int>& kv1,const pair<string,int>& kv2)
    {
        return kv1.second<kv2.second || (kv1.second==kv2.second)&&kv1.first>kv2.first;
    }
};
class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string,int> mymap;
        for(auto& ele:words)
        {
            mymap[ele]++;
        }
        priority_queue<pair<string,int>,vector<pair<string,int>>,mycompare> mypriority(mymap.begin(),mymap.end());
        vector<string> ret;
        for(int i=0;i<k;i++)
        {
            ret.push_back(mypriority.top().first);
            mypriority.pop();
        }
        return ret;
    }
};

C++ STL：set和map的结构及接口使用
weixin_43908419的博客
05-07 1440
本文讲解了C++ STL中set和map的基本结构功能以及主要接口函数的使用方法。
C++：map和set的使用
Makise的博客
09-02 1216
一篇带你完全掌握set和map的使用
一文搞懂 C++ 中 std::set、std::unordered_set、std::map 和 std::unordered_map 的用法与选择策略
小庞的博客
05-20 1202
在C++编程中，std::set、std::unordered_set、std::map和std::unordered_map是常用的关联容器，用于存储唯一键值。std::set和std::map基于红黑树实现，元素自动排序，适合需要有序存储和范围查询的场景，时间复杂度为O(log n)。std::unordered_set和std::unordered_map基于哈希表实现，元素无序存储，适合需要快速查找、插入和删除的场景，平均时间复杂度为O(1)，最坏情况下为O(n)。选择容器时需考虑是否需要排序、范围
【C++/STL】：set和map的介绍及基本使用
2301_77900444的博客
07-19 2236
在前面，我们已经接触过STL中的部分容器，比如：vector、list、deque等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。(1) set是按照一定次序存储元素的容器(2) 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。
C++: map和set的使用
dao_shadow的博客
08-04 1125
1. set是按照一定次序存储元素的关联性容器2. 在set中，键值对为<value,value>，并且每个value都是唯一的。set中的元素不能在容器中直接修改，但是可以从容器中插入或删除它们，从而间接修改。3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则（不允许存在相同的关键字）进行排序。4. set在底层是用红黑树实现的。
【C++】：set和map
Yikefore的博客
12-06 1600
map和set的使用详解，其中包含对map重载的operator[]的详细解读原理。
C++ STL中 set 和 map 的区别
红军不怕远征难，万水千山只等闲
10-08 2247
set和map是C++ STL中两种重要的关联容器，它们各自有不同的特点和适用场景。set主要用于存储唯一且排序的元素，而map则用于存储键值对，并根据键进行排序。尽管它们在底层实现上有许多相似之处，但在接口和使用上却有明显的区别。通过理解这些区别，我们可以更好地选择和使用它们，以满足不同的编程需求。
STL：map和set的使用
weixin_51142926的博客
04-20 2755
在STL中，总共实现了两种类型的关联性容器：树形结构与哈希结构，树型结构的关联式容器主要有四种：map、set、multimap、multiset。 这四种容器的共同点是：底层使用的是平衡搜索树（即红黑树）去实现的，容器中的元素是一个有序的序列。
【绝对有用】C++ 哈希 std::unordered_map 和 std::unordered_set
qq_43552933的博客
06-20 1582
这段代码通过以下步骤计算一个计算p.first的哈希值。计算p.second的哈希值，并将其左移 1 位。将上述两个哈希值按位异或，得到最终的哈希值。这个哈希函数结合了两个整数的哈希值，通过左移和异或运算，减少了哈希冲突，提高了哈希表的性能。**和是 C++ 标准库中的两个容器，分别用于存储键值对和唯一元素。以下是这两个容器的详细用法，包括它们的主要成员函数和一些常见操作的示例。**
C++必修：set/map，mutiset/mutimap的用法
Bettysweetyaaa的博客
08-25 1466
想深入了解 C++ 中的关联容器吗？本文将为你详细介绍 `set`、`multiset`、`map` 和 `multimap` 的特点与功能！它们具有独特的存储和排序方式，支持多种初始化和操作方式。快来探索这些关联容器的奥秘，提升你的 C++ 编程技能吧！
《解锁C++ STL的隐藏宝藏：set与map实战全攻略》
10-12
本文深入讲解了C++ STL中set与map容器的核心特性及实战应用，涵盖其底层红黑树实现带来的有序性与唯一性特点，详细介绍了insert、find、count、erase等常用成员函数的使用方法，并探讨了自定义排序规则（如仿函数和...
C++:set和map
m0_61088872的博客
07-11 1037
map的插入后，不论成功与否，都会返回一个pair<iterator, bool>，iterator用于指向key的迭代器，bool用于标识插入是否成功。而map的节点是pair<key, value>，所以我们解引用得到了一个pair，随后通过( ).second访问pair<key, value>的second，也就是value。它是基于红黑树实现的，它可以存储不重复的元素，并且会自动按照元素的大小进行排序。中的每个元素都由一个键和一个与之关联的值组成，键和值可以是任意类型。的类型）来调用默认构造。
C++：二叉搜索树
2301_78901562的博客
12-22 2215
本文详细介绍了二叉搜索树的概念、性能分析及实现方法。首先阐述了二叉搜索树的定义和特性，分析了其最优和最差情况下的时间复杂度。然后重点讲解了二叉搜索树的增删查操作的具体实现，包括节点定义、基本结构、插入、查找和删除算法，并提供了完整的代码示例。接着介绍了key和(key,value)两种结构的二叉搜索树，说明了它们的使用场景差异。最后给出了二叉搜索树在实际应用中的典型场景，如车库管理系统、词典翻译等。文章内容详实，对理解二叉搜索树的原理和实现具有很好的参考价值。
06_C 语言数据结构与算法：哈希表（散列表）—— O(1)查找的终极方案
最新发布
weixin_40369941的博客
12-22 912
/ 哈希表节点（键值对，链表结构）char *key;// 键（字符串类型，可替换为int、long等）int value;// 值（整数类型，可替换为结构体等）// 下一个节点} HashNode;// 哈希表结构（数组+链表）int size;// 哈希表的大小（数组长度）// 哈希桶（数组，元素为指向链表头节点的指针）哈希表是实现O(1)查找的核心数据结构，其核心是哈希函数的均匀性和冲突解决机制。在C语言中，数组+链表的链表法。
QtWeatherApp - 简单天气预报软件(C++ Qt6)(附源码)
sweetikelike的博客
12-18 1127
摘要：QtWeatherApp 是一个基于 Qt 6 和 C++ 开发的桌面天气预报应用。该软件通过 OpenWeatherMap Geocoding API 获取城市经纬度，再调用 Open-Meteo 免费天气 API 查询当前天气和7天预报。核心功能包括：支持中英文城市查询、显示温度及天气描述、纯 C++ 实现 Qt 网络请求和 JSON 解析。项目采用模块化设计，包含网络请求、数据处理和 UI 交互组件，可作为学习 Qt 开发的参考案例。软件跨平台支持 Windows/macOS/Linux，源码已
传值还是传引用？c++，python对比
ULTRAmanTAROACE的博客
12-18 552
操作PythonJavaC++传参（基本/不可变）引用（表现如值）值（primitive） / 引用副本（对象）值（拷贝）传参（容器/可变）引用（共享对象）引用副本（可修改内容）值（拷贝整个容器，除非用返回值返回对象引用primitive：值；对象：引用返回值（通常移动或 RVO 优化）赋值 a = ba 绑定到 b 所指对象primitive：值拷贝；对象：引用拷贝深拷贝（调用 operator=）push 到容器存储对象引用存储对象引用拷贝或移动元素（值语义）
【实战】C/C++ 实现 PC 热点（手动开启）+ 手机 UDP 自动发现 + TCP 通信全流程（超详细）
weixin_71604156的博客
12-17 983
本文提出了一种PC与手机本地无线通信的完整解决方案。通过手动开启PC热点、UDP广播自动发现和TCP可靠通信的技术组合，实现了设备间免配置的稳定连接。方案包含详细的技术原理分析、跨平台实现代码（C/C++和Android/Kotlin）以及实际部署指南，解决了传统方案中IP配置复杂、网络依赖强等问题。核心创新点在于解耦热点创建与通信逻辑，采用UDP发现+TCP通信+心跳保活的三重机制，在保证通信可靠性的同时降低了权限要求和实现复杂度。
C++ 类与对象：解锁面向对象编程的核心密码（中）
emtai486的博客
12-20 883
默认成员函数：构造，析构，拷贝构造，赋值重载，取地址重载
华为OD机试真题精讲：查找单入口空闲区域（Python/Java/C++多语言实现）
weixin_50859396的博客
12-22 10
本文讲解华为OD机试高频题「查找单入口空闲区域」的解题思路与多语言实现。题目要求在0/1矩阵中找出仅有一个入口的连通空闲区域，并按特定规则排序输出。核心解题步骤包括：边界遍历筛选入口候选、BFS/DFS查找连通区域、统计入口数量、筛选单入口区域并排序。文章提供Python实现代码，采用BFS算法高效处理大规模数据，通过visited矩阵避免重复访问，时间复杂度O(mn)。示例分析展示了单入口、多入口等典型场景的处理逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值