map和set的使用

C++中map和set的使用详解
于 2025-09-20 15:48:05 发布
阅读量939 收藏 34
点赞数 32
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++ map set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_89035880/article/details/149841869

map和set的使用

1. 序列式容器和关联式容器

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

关联式容器也是⽤来存储数据的，与序列式容器不同的是，关联式容器逻辑结构通常是⾮线性结构，两个位置有紧密的关联关系，交换⼀下，他的存储结构就被破坏了。关联式容器有map/set系列和unordered_map/unordered_set系列。

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

2. set系列的使用

2.1 set和multiset参考文档

set和multiset参考文档

2.2 set类的介绍

  1. set的声明如下，T就是set底层关键字的类型。
  2. set默认要求T支持小于比较，如果不⽀持或者想按⾃⼰的需求走可以⾃⾏实现仿函数传给第⼆个模版参数。
  3. set底层存储数据的内存是从空间配置器申请的，如果需要可以⾃⼰实现内存池，传给第三个参数。
  4. ⼀般情况下，我们都不需要传后两个模版参数。
  5. set底层是⽤红⿊树实现，增删查效率是O(logN)，迭代器遍历是⾛的搜索树的中序，所以是有序的。
  6. 前⾯部分我们已经学习了vector/list等容器的使⽤，STL容器接⼝设计，⾼度相似，所以这⾥我们就不再⼀个接⼝⼀个接⼝的介绍，而是挑⽐较重要的接⼝进⾏介绍。
template < class T,                     // set::key_type/value_type   
		   class Compare = less<T>,     // set::key_compare/value_compare   
		   class Alloc = allocator<T>   // set::allocator_type   
		   > class set;

2.3 set的构造和迭代器

set的构造我们关注以下⼏个接⼝即可。

set⽀持正向和反向迭代遍历，遍历默认按升序顺序，因为底层是⼆叉搜索树，迭代器遍历⾛的中序；⽀持迭代器就意味着⽀持范围for，set的iterator和const_iterator都不⽀持迭代器修改数据，因为修改关键字数据会破坏底层搜索树的结构。

// empty (1) ⽆参默认构造
explicit set (const key_compare& comp = key_compare(),
			  const allocator_type& alloc = allocator_type());
			  
// range (2) 迭代器区间构造
template <class InputIterator>
  set (InputIterator first, InputIterator last,
	   const key_compare& comp = key_compare(),
	   const allocator_type& = allocator_type());
	   
// copy (3) 拷⻉构造
set (const set& x);

// initializer list (5) initializer 列表构造
set (initializer_list<value_type> il,
     const key_compare& comp = key_compare(),
     const allocator_type& alloc = allocator_type());

// 迭代器是⼀个双向迭代器
iterator -> a bidirectional iterator to const value_type

// 正向迭代器
iterator begin();
iterator end();

// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();

2.4 set的增删查

set的增删查关注以下⼏个接⼝即可：

Member types
key_type   -> The first template parameter (T)
value_type -> The first template parameter (T)

// 单个数据插⼊，如果已经存在则插⼊失败
pair<iterator,bool> insert (const value_type& val);

// 列表插⼊，已经在容器中存在的值不会插⼊
void insert (initializer_list<value_type> il);

// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
template <class InputIterator>
void insert (InputIterator first, InputIterator last);

// 查找val，返回val所在的迭代器，没有找到返回end() 
iterator find (const value_type& val);

// 查找val，返回val的个数
size_type count (const value_type& val) const;

// 删除⼀个迭代器位置的值
iterator  erase (const_iterator position);

// 删除val，val不存在返回0，存在返回1 
size_type erase (const value_type& val);

// 删除⼀段迭代器区间的值
iterator erase (const_iterator first, const_iterator last);

// 返回⼤于等val位置的迭代器
iterator lower_bound (const value_type& val) const;

// 返回⼤于val位置的迭代器
iterator upper_bound (const value_type& val) const;

2.5 insert和迭代器遍历使用样例

#include <iostream>
#include <set>
#include <string>

using namespace std;

int main()
{
	// 去重 + 排升序
	set<int> s;
	// 去重 + 排降序（给一个大于的仿函数）
	//set<int, greater<int>> s;
	s.insert(5);
	s.insert(7);
	s.insert(2);
	s.insert(5);

	set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		//*it = 4; // 不支持修改
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 插入一段initializer_list列表值，已经存在的值插入失败
	s.insert({ 2, 8, 3, 9 });

	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;

	set<string> strset = { "sort", "insert", "add" };
	for (auto e : strset)
	{
		cout << e << " ";
	}
	cout << endl;
 
	return 0;
}

在这里插入图片描述

2.6 find和erase使用样例

#include <iostream>
#include <set>

using namespace std;

int main()
{
	set<int> s = { 4, 2, 7, 2, 8, 5, 9 };
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl << endl;

	// 删除最小值
	s.erase(s.begin());
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl << endl;

	// 直接删除 x
	int x;
	cin >> x;
	int num = s.erase(x);
	if (num == 0)
	{
		cout << x << "不存在" << endl;
	}
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl << endl;

	// 直接查找再利用迭代器删除 x
	cin >> x;
	auto pos = s.find(x);
	if (pos != s.end())
	{
		s.erase(pos);
	}
	else
	{
		cout << x << "不存在" << endl;
	}
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl << endl;

	// 算法库的查找是暴力查找 O（N）
	auto pos1 = find(s.begin(), s.end(), x);
	// set自身实现的查找利用搜索树的特性 O（logN）
	auto pos2 = s.find(x);

	// 利用count间接实现快速查找
	cin >> x;
	if (s.count(x))
	{
		cout << x << "存在" << endl;
	}
	else
	{
		cout << x << "不存在" << endl;
	}

	return 0;
}

在这里插入图片描述

2.7 lower_bound和upper_bound使用样例

#include <iostream>
#include <set>

using namespace std;

int main()
{
	set<int> myset;
	for (int i = 1; i < 10; ++i)
	{
		myset.insert(i * 10); // 10 20 30 40 50 60 70 80 90
	}

	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;

	// 实现查找并删除[35, 75]区间的值
	auto itlow = myset.lower_bound(35); // 返回>=35
	auto itup = myset.upper_bound(75); // 返回>75

	myset.erase(itlow, itup);

	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

在这里插入图片描述

2.8 multiset和set的差异

#include <iostream>
#include <set>

using namespace std;

int main()
{
	// multiset和set的头文件都是#include <set>
	// 相比set不同的是，multiset只排序，但不去重
	multiset<int> s = { 4, 2, 7, 2, 4, 8, 4, 5, 4, 9, 8, 7, 8 };
	auto it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl << endl;

	// find 返回中序的第一个
	int x;
	cin >> x;
	auto pos = s.find(x);
	while (*pos == x)
	{
		// 依次输出所有的 x
		cout << *pos << " ";
		++pos;
	}
	cout << endl << endl;

	// 返回 x 的个数
	cout << s.count(x) << endl << endl;

	// 删除所有的 x，并返回删除的个数
	cout << s.erase(x) << endl << endl;
	
	it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl << endl;
	
	// 删除中序第一个x
	cin >> x;
	pos = s.find(x);
	if (pos != s.end())
	{
		s.erase(pos);
	}

	it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl << endl;

	return 0;
}

在这里插入图片描述

2.9 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;
        // 遍历s1
        for(auto e : s1)
        {
        	// 如果s2中存在 e ，就尾插
           	if(s2.count(e))
            {
                v.push_back(e);
            }
        }

        return v;
    }
};

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;
        auto it1 = s1.begin();
        auto it2 = s2.begin();
        // 其中一个结束，就结束
        while(it1 != s1.end() && it2 != s2.end())
        {
        	// 遍历到不相等的值就谁小谁++
            if(*it1 < *it2)
            {
                ++it1;
            }
            else if(*it2 < *it1)
            {
                ++it2;
            }
            else // 遍历到相等的值就尾插，都++
            {
                v.push_back(*it1);
                ++it1;
                ++it2;
            }
        }
        return v;
    }
};

2.10 142.环形链表Ⅱ - 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*> s;
        ListNode* cur = head;
        while(cur)
        {
        	// 如果 cur 不在 s 中，说明第一次遇到，插入
            if(!s.count(cur)) // if(s.find(cur) == s.end())
            {
                s.insert(cur);
            }
            // 如果 cur 在 s 中，说明是环形链表，且 cur 指向的节点就是入口点
            else
            {
                return cur;
            }
            cur = cur->next;
        }
        
		// 说明该链表不带环 
        return nullptr;
    }
};

3. map系列的使用

3.1 map和multimap参考文档

map和multimap参考文档

3.2 map类的介绍

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

template < class Key,                                    // map::key_type          
		   class T,                                      // map::mapped_type 
		   class Compare = less<Key>,                    // map::key_compare 
		   class Alloc = allocator<pair<const Key,T> >   //map::allocator_type
		   > class map;

3.3 pair类型介绍

map底层的红⿊树节点中的数据，使⽤pair<Key,T>存储键值对数据。

typedef pair<const Key, T> value_type;

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)
	{}
};

template <class T1,class T2>
inline pair<T1,T2> make_pair (T1 x, T2 y)
{
	return ( pair<T1,T2>(x,y) );
}

3.4 map的构造

map的构造我们关注以下⼏个接⼝即可。

map的⽀持正向和反向迭代遍历，遍历默认按key的升序顺序，因为底层是⼆叉搜索树，迭代器遍历⾛的中序；⽀持迭代器就意味着⽀持范围for，map⽀持修改value数据，不⽀持修改key数据，因为修改关键字数据会破坏底层搜索树的结构。

// empty (1) ⽆参默认构造
explicit map (const key_compare& comp = key_compare(),
			  const allocator_type& alloc = allocator_type());
			  
// range (2) 迭代器区间构造
template <class InputIterator>
	map (InputIterator first, InputIterator last,
		 const key_compare& comp = key_compare(),
		 const allocator_type& = allocator_type());
		 
// copy (3) 拷⻉构造
map (const map& x);

// initializer list (5) initializer 列表构造
map (initializer_list<value_type> il,
	 const key_compare& comp = key_compare(),
	 const allocator_type& alloc = allocator_type());
	 
// 迭代器是⼀个双向迭代器
iterator   -> a bidirectional iterator to const value_type

// 正向迭代器
iterator begin();
iterator end();

// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();

3.5 map的增删查

map的增删查关注以下⼏个接⼝即可：

map增接⼝，插⼊的pair键值对数据，跟set所有不同，但是查和删的接⼝只⽤关键字key跟set是类似的，不过find返回iterator，不仅仅可以确认key在不在，还找到key映射的value，同时通过迭代还可以修改value。

Member types
key_type     -> The first template parameter (Key)
mapped_type  -> The second template parameter (T)
value_type   -> pair<const key_type,mapped_type>

// 单个数据插⼊，只要key已经存在就会插⼊失败
pair<iterator,bool> insert (const value_type& val);

// 列表插⼊，已经在容器中存在的值不会插⼊
void insert (initializer_list<value_type> il);

// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
template <class InputIterator>
void insert (InputIterator first, InputIterator last);

// 查找k，返回k所在的迭代器，没有找到返回end() 
iterator find (const key_type& k);

// 查找k，返回k的个数
size_type count (const key_type& k) const;

// 删除⼀个迭代器位置的值
iterator  erase (const_iterator position);

// 删除k，k不存在返回0，存在返回1 
size_type erase (const key_type& k);

// 删除⼀段迭代器区间的值
iterator  erase (const_iterator first, const_iterator last);

// 返回⼤于等k位置的迭代器
iterator lower_bound (const key_type& k);

// 返回⼤于k位置的迭代器
const_iterator lower_bound (const key_type& k) const;

3.6 构造遍历及增删查使用样例

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

using namespace std;

int main()
{
	// initializer_list构造
	map<string, string> dict = { {"sort", "排序"}, {"left", "左边"}, {"right", "右边"} };

	map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		//cout << (*it).first << ":" << (*it).second << endl;
		// 这里省略了一个->
		// 第一个->是迭代器运算符重载，返回pair*
		// 第二个->是结构体指针解引用取pair数据
		//cout << it->first << ":" << it->second << endl;
		cout << it.operator->()->first << ":" << it.operator->()->second << endl;
		++it;
	}
	cout << endl << endl;

	pair<string, string> kv1("first", "第一个");
	dict.insert(kv1); // 有名对象
	dict.insert(pair<string, string>("second", "第二个")); // 匿名对象
	// make_pair比起有名对象和匿名对象就是不需要声明模板参数
	dict.insert(make_pair("third", "第三个")); // 自动推导参数类型，并返回匿名对象
	dict.insert({ "auto", "自动的" }); // 隐式类型转换

	// "sort"已经存在，插入失败
	dict.insert({ "sort", "排序" });

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

	string str;
	while (cin >> str)
	{
		auto ret = dict.find(str);
		if (ret != dict.end())
		{
			cout << ret->second << endl;
		}
		else
		{
			cout << "无此单词，请重新输入" << endl;
		}
	}

	return 0;
}

在这里插入图片描述

3.7 map的迭代器和[]功能样例

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

using namespace std;

int main()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	map<string, int> countMap;

	for (auto& str : arr)
	{
		//auto ret = countMap.find(str);
		//if (ret == countMap.end())
		//{
		//	countMap.insert({ str, 1 });
		//}
		//else
		//{
		//	ret->second++;
		//}

		// 1、不在,说明水果第一次出现，则插入{水果, 0}，同时返回次数的引用，++就变成1次了
		// 2、在，则返回水果对应的次数的引用并++
		countMap[str]++; // 该代码与上面的代码效果等价
	}

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

	return 0;
}

在这里插入图片描述

3.7.1 map的operator[]是怎么实现的？

pair<iterator,bool> insert (const value_type& val);
// insert既具有插入的功能也具有查找的功能
// pair<iterator, bool>
// 该pair的first成员是一个迭代器，指向要么是新插入的元素，要么是map中已存在的具有等效键的元素
// 该pair的second成员是一个布尔值：如果新元素被成功插入，则为true；如果等效键已存在，则为false

// operator的内部实现
mapped_type& operator[] (const key_type& k)
{
	// 1、如果k不在map中,insert会插⼊k和mapped_type默认值，同时[]返回结点中存储mapped_type值的引⽤，
	// 那么我们可以通过引⽤修改返映射值。所以[]具备了插⼊+修改功能
	 
	// 2、如果k在map中，insert会插⼊失败，但是insert返回pair对象的first是指向key结点的迭代器，
	// 返回值同时[]返回结点中存储mapped_type值的引⽤，所以[]具备查找+修改的功能
   pair<iterator, bool> ret = insert({ k, mapped_type() });
   iterator it = ret.first;
   return it->second;
}

// 通俗易懂的写法
V& operator[](const K& key)
{
	pair<iterator, bool> ret = insert({key, V()});
	return (ret.first)->second;
}

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

using namespace std;

int main()
{
	map<string, string> dict;
	dict.insert({ "sort", "排序" });

	// 插入 + 修改
	dict["insert"] = "插入";

	// 插入
	dict["auto"];

	// 修改
	dict["auto"] = "自动的";

	// key已存在，插入失败
	dict.insert({ "sort", "排序xxx" });

	// key存在是查找，不存在是插入
	cout << dict["sort"] << endl;

	return 0;
}

在这里插入图片描述

3.8 multimap和map的差异

multimap和map的使⽤基本完全类似，主要区别点在于multimap⽀持关键值key冗余，那么insert/find/count/erase都围绕着⽀持关键值key冗余有所差异，这⾥跟set和multiset完全⼀样，⽐如find时，有多个key，返回中序第⼀个。其次就是multimap不⽀持[]，因为⽀持key冗余，[]就只能⽀持插⼊了，不能⽀持修改。

int main()
{
	// 与multiset和set的区别类似，multimap可以插入多个相同的key值
	// 也就是说multimap只要插入就会成功
	multimap<string, string> dict;
	dict.insert({ "sort", "排序" });
	dict.insert({ "sort", "排序" });
	dict.insert({ "sort", "排序xxx" });
	dict.insert({ "left", "左边" });

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

	// 但是multimap就没有operator[]了，因为多个相同的key，
	// value如果不同的话，就不知道要返回哪个value了。

	//// 会删除所有的"sort"
	//dict.erase("sort");

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

	//equal_range 返回key值相等的迭代器区间[ )
	auto itpair = dict.equal_range("sort");
	auto it = itpair.first;
	while (it != itpair.second)
	{
		cout << it->first << ":" << it->second << endl;
		++it;
	}

	return 0;
}

在这里插入图片描述

3.9 138.随机链表的复制 - LeetCode

这个是数据结构阶段用链表实现的版本，还是比较麻烦的。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

// 在原链表每个节点后插入复制节点
void AddNode(Node* head) 
{
    Node* pcur = head;
    while (pcur) 
    {
        Node* newnode = new Node(pcur->val);
        Node* next = pcur->next;
        newnode->next = next;
        pcur->next = newnode;
        pcur = next;
    }
}

// 设置复制节点的random指针
void SetRandom(Node* head) 
{
    Node* pcur = head;
    while (pcur) 
    {
        Node* copy = pcur->next;
        if (pcur->random)
            copy->random = pcur->random->next;
        pcur = copy->next;
    }
}


class Solution {
public:
    // 复制带随机指针的链表
    Node* copyRandomList(Node* head) {
        if (head == nullptr)
            return head;

        // 在原链表的基础上拷贝新节点并插入在原链表中
        AddNode(head);
        
        // 设置random指针
        SetRandom(head);
        
        // 断开新旧链表,将旧链表还原并将新链表依次连接
        Node* pcur = head;
        Node* copyHead = head->next;
        Node* copyTail = copyHead;
        
        while (copyTail->next) 
        {
            pcur->next = copyTail->next;
            pcur = pcur->next;
            copyTail->next = pcur->next;
            copyTail = copyTail->next;

        }
        // 恢复原链表的最后一个节点的next为nullptr
        pcur->next = nullptr;
        
        return copyHead;
    }

};

该版本利用map将<原链表，新链表>关联起来，使得链接random时更加简便。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        //  原链表  新链表
        map<Node*, Node*> nodeMap;
        Node* pcur = head;
        Node* copyHead = nullptr, *copyTail = nullptr;
	
		// 深拷贝原链表，并将原链表和新链表关联起来
        while(pcur)
        {
            // 尾插
            Node* newnode = new Node(pcur->val);
            if(copyTail == nullptr)
            {
                copyHead = copyTail = newnode;
            }
            else
            {
                copyTail->next = newnode;
                copyTail = copyTail->next;
            }
            nodeMap[pcur] = copyTail;
            pcur = pcur->next;
        }
		
		// 链接random
        pcur = head;
        Node* copy = copyHead;
        while(pcur)
        {
            if(pcur->random)
            {
                copy->random = nodeMap[pcur->random];
            }
            pcur = pcur->next;
            copy = copy->next;
        }
        
        return copyHead;
    }
};

3.10 692.前K个高频单词 - LeetCode

解法一：⽤排序找前k个单词，因为map中已经对key单词排序过，也就意味着遍历map时，次数相同的单词，字典序⼩的在前⾯，字典序⼤的在后⾯。那么我们将数据放到vector中⽤⼀个稳定的排序就可以实现上⾯特殊要求，但是sort底层是快排，是不稳定的，所以我们要⽤stable_sort，他是稳定的。当然也可以用不稳定的快排，但是需要在比较函数中做些修改。

稳定的排序有：冒泡、直接插入、归并。

bool cmp(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:

    // 仿函数    
    struct Compare
    {
        bool operator()(const pair<string, int>& kv1, const pair<string, int>& kv2)
        {
            // 按单词出现次数降序排序
            return kv1.second > kv2.second;
        }
    };

    // // 仿函数    
    // struct Compare
    // {
    //     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);
    //     }
    // };

    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string, int> cntMap;
        for(auto& e : words)
        {
            ++cntMap[e];
        }

        // 将cntMap赋值过来之前，单词已经按字典序拍过了
        vector<pair<string, int>> v(cntMap.begin(), cntMap.end());

		// 可以用普通的函数传函数指针，也可以用仿函数传匿名对象
		
        // 只需要一个稳定的排序算法，把单词的出现此处再排成降序即可
        //stable_sort(v.begin(), v.end(), Compare());

        sort(v.begin(), v.end(), cmp);

        vector<string> ret;
        for(int i = 0; i < k; ++i)
        {
            ret.push_back(v[i].first);
        }

        return ret;
    }
};

解法二：用TopK的解法，利用大根堆求解

typedef pair<string, int> PSI;

class Solution {
public:

    struct Compare
    {
        bool operator()(const PSI& kv1, const PSI& kv2)
        {
            // 要注意优先级队列底层是反的，大根堆要实现小于比较，所以要反着来
            return kv1.second < kv2.second || (kv1.second == kv2.second && kv1.first > kv2.first);
        }
    };

    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string, int> cntMap;
        for(auto& e : words)
        {
            ++cntMap[e];
        }

        priority_queue<PSI, vector<PSI>, Compare> q(cntMap.begin(), cntMap.end());

        vector<string> ret;
        for(int i = 0; i < k; ++i)
        {
            string t = q.top().first;
            ret.push_back(t);
            q.pop();
        }

        return ret;
    }
};
javascript中的Map和Set
低代码布道师的博客
09-04 1389
我们本篇介绍了JS中两种常见的数据结构，随着你开发的深入，这些知识点必然会用到，先把它储备好，在用的时候就有备选的方法。要不然只能靠笨办法去实现，效率和性能就不太高。
【C++】map和set的使用
qq_66314292的博客
02-21 1446
map与set
set的使用
tb_youth的博客
11-20 344
1680: 查找1 Time Limit: 1 Sec Memory Limit: 128 MB [Submit][Status][Web Board] Description 给你一个长度是n的序列A，然后，有m次询问，每次询问是一个数字X，请你告诉我X在序列A中是否存在，存在输出YES，否则输出NO Input 第一行 ，n,m,(n,m&amp;amp;lt;=100000) 第二行n个数(每个数&amp;amp;lt;...
Set的使用
m0_52346373的博客
05-20 586
Set的特点 1.Set中存储的是无序，唯一的元素。 2.Set因为是无序的所以也就没有索引，所以List中关于索引的方法，在Set中就没有了。同时，也就不能用for循环，来实行对集合遍历。 3.Set的两个实现类HashSet和TreeSet。HashSet是无序的，但TreeSet是自然有序的，就是大小顺序。 向Set中添加自定义对象的注意点 1.任意对象想要放入底层结构是哈希表的集合中，都要重写equals方法和Hashcode方法来保证唯一性。 2，任意想要放入底层结构是红黑数的集合中，都要实现一个
Set使用方法
我的博客
02-25 1440
Set 是一个集合， 没有key， set集合内部的值是唯一的； Set 语法 new Set(iterable) 创建set， 可以传入可迭代的对象，一般是数组 set.add(value) 添加值到set中， 返回set本身 set.delete（value） 删除值， 值存在返回true， 否则返回false set.has（value） 判断value是否在set中，在返回true， 否则返回false set.clear() 清空set set.size 返回集合个数，类似length ​.
关于set的用法
persistence_s的博客
06-05 567
map的元素都是“实值/键值”所形成的一个对组。每个元素都有一个键，是排序的准则。每个键只能出现一次，不允许重复使用。map可以被视为关联式数组，也就是具有任意索引型别的数组。 set内部的元素根据其值自动排序，可以将set视作一种特殊的map，其元素实值就是键值。关于STL中set的用法：1、set的迭代器的使用： #include<iostream> #include<stdlib.h> #
C++：map和set的使用
Makise的博客
09-02 1166
一篇带你完全掌握set和map的使用
一文搞懂ES6中的Map和Set
10-16
ES6（ECMAScript 6，也称为ECMAScript 2015）引入了两个新的集合类型：Map和Set。这两种类型在JavaScript中非常有用，尤其是在需要存储键值对或唯一值的场景中。Map和Set的引入，提高了JavaScript的数据处理能力，...
Map和Set的区别
12-21
在C++标准模板库（STL）中，`Map` 和 `Set` 是两种关联容器，它们都提供了高效的数据存储和检索能力。然而，它们在数据结构、存储方式以及使用场景上有着显著的区别。 首先，`Map` 是一个键值对（Key-Value Pair）...
set的基本使用
提拉米苏的博客
03-14 933
set的英文意思是“集合”， 集合都不陌生吧，集合的特点有唯一性，即：每一个元素只有一个，所以set可以用来“去重”操作，set还有默认的排序。  1、头文件——  2、定义——setQ;  3、输入（插入）——insert(x);  4、有序输出  set::iterator it;  for(it = Q.begin(); it != Q.end(); it++)  cout
set的常见用法
Allen的博客
04-10 652
set翻译为集合，是一个内部自动有序且不含重复元素的容器。在考试中有可能出现需要去掉重复元素的情况，而且有可能因这些元素比较大或者类型不是int型而不能直接开散列表，在这种情况下就可以用set来保留元素本身而不考虑它的个数。当然，上面说的情况也可以通过再开一个数组进行下标和元素的对应来解决，但是set提供了更为直观的接口，并且加入set知乎可以实现自动排序，因此熟练使用set可以在做某些题时减少思维量。 #include<iostream> #include<set> usi..
set相关用法
席同学的博客
12-29 266
java中Set的用法 Set集合的特点： 不能存储相同的元素。 同时因为其是一个抽象的接口：所以不能直接实例化一个set对象。(Set s = new Set() )错误 该接口主要继承于Collections接口，所以具有Collection的一些常见的方法。 常见的方法： Sr.No. Method &amp;amp; Description add( ) 向集合中添加元素 cl...
set基本用法
Hello，小高同学
03-20 1890
set跟vector差不多，它跟vector的唯一区别就是，set里面的元素是有序的且唯一的，只要你往set里添加元素，它就会自动排序，而且，如果你添加的元素set里面本来就存在，那么这次添加操作就不执行。要想用set先加个头文件set。 在c98中，set不能直接赋值，而需要一个一个插入进去（ insert() ）。但是有种巧妙赋值 #include<iostream> #i...
set 的详细用法（set 排序、set 的遍历、set 的多种倒序遍历方法、set 的基本成员函数）
wcj_______的博客
08-19 9306
set 的详细用（set 排序、set 的遍历、set 的多种倒序遍历方法、set 的基本成员函数）
set的常见用法详解
热门推荐
辉小歌的博客
03-24 2万+
目录set的定义set容器内元素的访问 set翻译为集合，是一个内部自动有序且不含重复元素的容器。在考试中，有可能出现需要去掉重复元素的情况，而且有可能因这些元素比较大或者类型不是int型而不能直接开散列表，在这种情况下就可以用set来保留元素本身而不考虑它的个数。当然，上面说的情况也可以通过再开一个数组进行下标和元素的对应来解决，但是set提供了更为直观的接口，并且加入set之后可以实现自动排序，因此熟练使用set可以在做某些题时减少思维量。 需要的头文件: #include<set>
Java之Set、HashSet、TreeSet常用Methods
山淼的博客
10-06 297
一、Set 用于存储无序（存和取的顺序不同）非重复元素。 如何做到元素不重复 通过hashCode方法和equals方法来保证元素的唯一性 二、HashSet HashSet是通过HasMap来实现的，HashMap的输入参数有Key、Value两个组成，在实现HashSet的时候，保持HashMap的Value为常量，相当于在HashMap中只对Key对象进行处理。 常用方法 boolean add(E e) 将指定的元素添加到此集合（如果尚未存在）。 void clear() 从此集合中删除所有元素。
Set集合的基本使用
weixin_67201964的博客
11-28 2138
Set集合基础知识以及基本方法的使用
Map和Set
最新发布
10-05
### 概念 在不同的编程语言中，Map 和 Set 有不同的实现，但基本概念相似。 在 JavaScript 里，Map 和 Set 是 ES6 引入的新数据结构，提供了比普通对象和数组更强大的特性和功能。Map 是键值对集合，而 Set 是唯一值的集合 [^1]。 在 Java 中，Map 和 Set 是专门用来进行搜索的容器或者数据结构。例如，在存储学生学号和姓名时，使用 Map 或 Set 能更高效地进行查找操作 [^5]。 在 C++ 中，set 是按照一定次序存储元素的容器。在 set 中，元素的 value 也标识它（value 就是 key，类型为 T），并且每个 value 必须是唯一的。而 map 存储的是真正的键值对 <key, value> [^3][^4]。 ### 使用方法 #### JavaScript - **Map**： ```javascript // 创建一个 Map const myMap = new Map(); // 添加键值对 myMap.set('name', 'John'); myMap.set('age', 30); // 获取值 const name = myMap.get('name'); console.log(name); // 检查键是否存在 const hasAge = myMap.has('age'); console.log(hasAge); // 删除键值对 myMap.delete('age'); // 遍历 Map myMap.forEach((value, key) => { console.log(key + ': ' + value); }); ``` - **Set**： ```javascript // 创建一个 Set const mySet = new Set(); // 添加值 mySet.add(1); mySet.add(2); mySet.add(2); // 重复的值不会被添加 // 检查值是否存在 const hasValue = mySet.has(1); console.log(hasValue); // 删除值 mySet.delete(2); // 遍历 Set mySet.forEach(value => { console.log(value); }); ``` #### C++ - **set**： ```cpp #include <iostream> #include <set> int main() { std::set<int> mySet; // 插入元素 mySet.insert(3); mySet.insert(1); mySet.insert(2); // 查找元素 auto it = mySet.find(2); if (it != mySet.end()) { std::cout << "Found: " << *it << std::endl; } // 遍历 set for (auto element : mySet) { std::cout << element << " "; } std::cout << std::endl; return 0; } ``` - **map**： ```cpp #include <iostream> #include <map> #include <string> int main() { std::map<std::string, int> myMap; // 插入键值对 myMap["apple"] = 5; myMap["banana"] = 3; // 查找键值对 auto it = myMap.find("apple"); if (it != myMap.end()) { std::cout << "Price of apple: " << it->second << std::endl; } // 遍历 map for (auto pair : myMap) { std::cout << pair.first << ": " << pair.second << std::endl; } return 0; } ``` ### 区别 - **存储内容**：Map 存储键值对，而 Set 只存储唯一的值 [^1][^3][^4]。 - **用途**：Map 更适合需要通过键来查找对应值的场景，而 Set 常用于去重或判断某个值是否存在 [^1][^4]。 - **数据结构底层实现**：在 C++ 中，set 和 map 在底层通常用二叉搜索树（红黑树）实现 [^3][^4]。
评论 36
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值