⭐博客主页:️CS semi主页
⭐欢迎关注:点赞收藏+留言
⭐系列专栏:C++进阶
⭐代码仓库:C++进阶
家人们更新不易,你们的点赞和关注对我而言十分重要,友友们麻烦多多点赞+关注,你们的支持是我创作最大的动力,欢迎友友们私信提问,家人们不要忘记点赞收藏+关注哦!!!
一、关联式容器
初期,我们接触了list,vector,deque等容器,这些容器统称为序列式容器,因为其底层为线性序列的数据结构,里面存储的是元素本身。
关联式容器也是用来存储数据的,与序列式容器不同的是,其里面存储的是<key, value>结构的键值对,在数据检索时比序列式容器效率更高。
二、键值对
键值对概念
用来表示具有一一对应关系的一种结构,该结构中一般只包含两个成员变量key和value,key代表键值,value表示与key对应的信息。
定义
SGI-STL中关于键值对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)
{}
};
三、set
set的介绍
- set是按照一定次序存储元素的容器
- 在set中,元素的value也标识它(value就是key,类型为T),并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const),但是可以从容器中插入或删除它们。
- 在内部,set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
- set容器通过key访问单个元素的速度通常比unordered_set容器慢,但它们允许根据顺序对子集进行直接迭代。
- set在底层是用二叉搜索树(红黑树)实现的。
1.与map/multimap不同,map/multimap中存储的是真正的键值对<key,value>,set中只放value,但在底层实际存放的是由<value, value>构成的键值对。
2. set中插入元素时,只需要插入value即可,不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素,可以得到有序序列
5. set中的元素默认按照小于来比较
6. set中查找某个元素,时间复杂度为: l o g 2 n log_2 n log2n
7. set中的元素不允许修改(为什么?)
8. set中的底层使用二叉搜索树(红黑树)来实现。
总结:set的本质就是key模型。
set的使用
set支持的操作为增删查,不能修改!
set的模板参数列表
T:set中存放元素的类型,实际在底层存储的是<value, value>的键值对
Compare:仿函数,set容器中默认使用库函数中的less函数来比较,我们如果想实现More函数我们可以自己进行写一个More函数以实现不同的功能。
Alloc:set中元素空间的管理方式,使用STL提供的空间配置器。
set的构造
void testset1()
{
set<int> set1;
int num[10] = { 1,2,4,3,5,7,6,8,9,10 };
// 区间构造
set<int> set2(num, num + sizeof(num) / sizeof(num[0]));
// 拷贝构造
set<int> set3(set2);// 拷贝构造代价太大
// for循环打印set2
for (auto& e : set2)
{
cout << e << " ";
}
cout << endl;
// for循环打印set3
for (auto& e : set3)
{
cout << e << " ";
}
cout << endl;
}
set的迭代器
如图所示:
void testset2()
{
set<int> set1 = { 1,2,1,4,5,3,7,6,5,8,9 };
set<int>::iterator it = set1.begin();
// 去重+排序
while (it != set1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// 范围for
for (auto& e : set1)
{
cout << e << " ";
}
cout << endl;
}
我们如果想要将这个排序变成降序该咋办呢?很简单,用一个Greater仿函数即可:
void testset3()
{
int a[10] = { 1,3,1,2,4,5,7,6,5,8 };
// 这个greater仿函数是set库函数中的函数
// 就是进行降序的函数
set<int, greater<int>> set1(a, a + sizeof(a) / sizeof(a[0]));
// for循环
for (auto& e : set1)
{
cout << e << " ";
}
cout << endl;
}
set的容量
empty
size
set的修改操作
insert
这里我们直接用cplusplus网站上的插入介绍和代码解析:
void testset4()
{
std::set<int> myset;
std::set<int>::iterator it;
std::pair<std::set<int>::iterator, bool> ret;
// for循环并单个插入
for (int i = 1; i <= 5; ++i)
myset.insert(i * 10);
// 单个插入
ret = myset.insert(20);
if (ret.second == false)
it = ret.first;
// 插入迭代器所代表的值
myset.insert(it, 25);
myset.insert(it, 24);
myset.insert(it, 26);
// 插入一段区间
int myints[] = { 5,10,15 };
myset.insert(myints, myints + 3);
std::cout << "myset contains:";
for (it = myset.begin(); it != myset.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
}
find && erase
void testset5()
{
std::set<int> myset;
std::set<int>::iterator it;
for (int i = 1; i < 10; i++)
myset.insert(i * 10); // 10 20 30 40 50 60 70 80 90
it = myset.begin();
++it; // 第二个位置
// 删除第二个位置
myset.erase(it);
// 删除一个数
myset.erase(40);
// 删除一个迭代器区间
it = myset.find(60);
myset.erase(it, myset.end());
std::cout << "myset contains:";
for (it = myset.begin(); it != myset.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
}
上面是erase,我们下面介绍一下find:
void testset6()
{
std::set<int> myset;
std::set<int>::iterator it;
for (int i = 1; i <= 5; i++)
myset.insert(i * 10); // 10 20 30 40 50
it = myset.find(20);
myset.erase(it); // 删除20这个迭代器的值
myset.erase(myset.find(40)); // 删除40这个迭代器的值
std::cout << "myset contains:";
for (it = myset.begin(); it != myset.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
}
看似没什么问题,有一个问题,那我们假如说删除了一个并不存在的数值或者是迭代器呢?
所以我们在写完find以后需要判断一下是否是真的找到了,找到了才能删除,找不到就不删除即可。
// 删除一个不存在的迭代器
set<int>::iterator pos = myset.find(70);
if (pos != myset.end())
{
myset.erase(pos);
}
count
lower_bound 和 upper_bound
void testset9()
{
set<int> myset;
set<int>::iterator itup, itlow;
for (int i = 1; i < 10; ++i)
{
myset.insert(i * 10);
}
itlow = myset.lower_bound(35);
itup = myset.upper_bound(60);
cout << "[" << *itlow << "," << *itup << "]" << endl;
myset.erase(itlow, itup);
for (auto& e : myset)
{
cout << e << " ";
}
cout << endl;
}
Multiset的用法
multiset的用法和set基本是一致的,唯一一个区别是multiset允许键值对冗余,即使用multiset可以让数字重复。
void testset10()
{
// multiset
int a[10] = {1,3,2,4,1,2,5,6,7,10};
multiset<int> set1(a, a + sizeof(a) / sizeof(a[0]));
for (auto& e : set1)
{
cout << e << " ";
}
cout << endl;
}
还有一个find和erase呢?
find是返回中序中的第一个(在有多个重复值的情况下)。
erase是将所有的想删除的值全部删掉。
四、map
map的介绍
- map是关联容器,它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
- 在map中,键值key通常用于排序和惟一地标识元素,而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同,并且在map的内部,key与value通过成员类型value_type绑定在一起,为其取别名称为pair: typedef pair<const key, T> value_type;
- 在内部,map中的元素总是按照键值key进行比较排序的。
- map中通过键值访问单个元素的速度通常比unordered_map容器慢,但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时,可以得到一个有序的序列)。
- map支持下标访问符,即在[]中放入key,就可以找到与key对应的value。
- map通常被实现为二叉搜索树(更准确的说:平衡二叉搜索树(红黑树))。
map的用法
map的模板参数
key: 键值对中key的类型
T: 键值对中value的类型
Compare: 比较器的类型,map中的元素是按照key来比较的,缺省情况下按照小于来比较,一般情况下(内置类型元素)该参数不需要传递,如果无法比较时(自定义类型),需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
Alloc:通过空间配置器来申请底层空间,不需要用户传递,除非用户不想使用标准库提供的空间配置器
map迭代器
void testmap1()
{
map<string, string> map1;
map1.insert(make_pair("banana", "香蕉"));
map1.insert(make_pair("apple", "苹果"));
map1.insert(make_pair("orange", "橙子"));
map<string, string>::iterator it = map1.begin();
while (it != map1.end())
{
cout << it->first << it->second << endl;
++it;
}
}
map的构造
void testmap2()
{
map<int, int> map1; // 空的构造
int a[] = { 1,2,3,4,5,6,7,8,88,9,10 };
for (auto& e : a)
{
map1.insert(make_pair(e, e));
}
map<int, int> map2(map1.begin(), map1.end()); // 迭代器区间构造
map<int, int> map3(map2); // 拷贝构造
for (auto& e : map3)
{
cout << e.first << "->" << e.second << endl;
}
}
map的常见修改操作
insert
void testmap3()
{
std::map<char, int> mymap;
// 匿名对象
mymap.insert(std::pair<char, int>('a', 100));
mymap.insert(std::pair<char, int>('z', 200));
// 在map中插入一个键值对,迭代器加判断是否插入成功
std::pair<std::map<char, int>::iterator, bool> ret;
ret = mymap.insert(std::pair<char, int>('z', 500));
if (ret.second == false)
{
std::cout << "element 'z' already existed";
std::cout << " with a value of " << ret.first->second << '\n';
}
// 插入一个迭代器位置加值
std::map<char, int>::iterator it = mymap.begin();
mymap.insert(it, std::pair<char, int>('b', 300));
mymap.insert(it, std::pair<char, int>('c', 400));
// 迭代器区间插入,利用begin()到find('c')的位置
std::map<char, int> anothermap;
anothermap.insert(mymap.begin(), mymap.find('c'));
std::cout << "mymap contains:\n";
for (it = mymap.begin(); it != mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
std::cout << "anothermap contains:\n";
for (it = anothermap.begin(); it != anothermap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
}
还有一种很省力的方法,使用make_pair(匿名对象),因为是make_pair返回的就是pair<T1,T2>(x, y),即自动识别类型。
#include<iostream>
using namespace std;
int main()
{
std::map<int, int> map1;
map1.insert(make_pair(1, 1));
map1.insert(make_pair(2, 2));
map1.insert(make_pair(3, 3));
for(auto& e : map1)
{
cout << e << " ";
}
cout << endl;
}
erase
void testmap4()
{
std::map<char, int> mymap;
std::map<char, int>::iterator it;
mymap.insert(make_pair('a', 10));
mymap.insert(make_pair('b', 20));
mymap.insert(make_pair('c', 30));
mymap.insert(make_pair('d', 40));
mymap.insert(make_pair('e', 50));
mymap.insert(make_pair('f', 60));
// 删除b这个位置的整个迭代器
it = mymap.find('b');
mymap.erase(it);
// 删除键值为c的元素
mymap.erase('c');
// 删除迭代器区间
it = mymap.find('e');
mymap.erase(it, mymap.end());
for (it = mymap.begin(); it != mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
}
find
void testmap5()
{
std::map<char, int> mymap;
std::map<char, int>::iterator it;
mymap.insert(pair<char, int>('a', 50));
mymap.insert(make_pair('b', 100));
mymap.insert(pair<char, int>('c', 150));
mymap.insert(pair<char, int>('d', 200));
// 找到b这个键值对
it = mymap.find('b');
if (it != mymap.end()) // 判断是否找到
mymap.erase(it);
std::cout << "elements in mymap:" << '\n';
std::cout << "a => " << mymap.find('a')->second << '\n';
std::cout << "c => " << mymap.find('c')->second << '\n';
std::cout << "d => " << mymap.find('d')->second << '\n';
}
count
void testmap6()
{
std::map<char, int> mymap;
char c;
mymap.insert(make_pair('a', 101));
mymap.insert(make_pair('b', 202));
mymap.insert(make_pair('c', 303));
mymap.insert(make_pair('d', 404));
for (c = 'a'; c < 'h'; c++)
{
std::cout << c;
if (mymap.count(c) > 0) // 数值大于0则输出是个有值的map
std::cout << " is an element of mymap.\n";
else
std::cout << " is not an element of mymap.\n";
}
}
map的容量与元素访问 – operator[]
empty和size都好讲,一个是判空,一个是算里面的数量,而重头戏在operator[]。
[]:有插入、查找和修改的功能。
1、map中有这个key,返回value的引用。
2、map中没有这个key的匹配值,则先构造一个pair(key, T()),先插入这个key值,再将value进行默认构造,最后返回value的引用。‘
[]的底层实现:
底层实现有两个pair的方式:
第一个是像上面所述的当key在map中的时候,返回的pair(key_iterator, false),当key不在map中,返回的是pair(new_key_iterator, true),即返回的是迭代器和bool值。
第二种则是kv模型的pair,是插入的pair的数据。
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V());
return ret.first->second;
}
利用map统计出现次数
用直接插入法
void test_map()
{
string arr[] = { "苹果","香蕉","橙子","苹果","香蕉","橙子","苹果","香蕉","橙子","梨","柠檬" };
map<string, int> fruitcount;
for (auto& e : arr)
{
map<string, int>::iterator it = fruitcount.find(e);
if (it != fruitcount.end())
{
it->second++;
}
else
{
// 刚进入
fruitcount.insert(make_pair(e, 1));
}
}
// 遍历
map<string, int>::iterator it = fruitcount.begin();
while (it != fruitcount.end())
{
cout << it->first << "=>" << it->second << endl;
++it;
}
cout << endl;
}
用[]法
void test_map1()
{
string arr[] = { "苹果","香蕉","橙子","苹果","香蕉","橙子","苹果","香蕉","橙子","梨","柠檬" };
map<string, int> fruitcount;
for (auto& e : arr)
{
//1、e不在fruitcount中,插入pair(e, int()),然后对返回次数++
//2、e在的话,就返回value的引用次数++
fruitcount[e]++;
}
// 遍历
map<string, int>::iterator it = fruitcount.begin();
while (it != fruitcount.end())
{
cout << it->first << "=>" << it->second << endl;
++it;
}
cout << endl;
}
multimap
multimap介绍
- Multimaps是关联式容器,它按照特定的顺序,存储由key和value映射成的键值对<key, value>,其中多个键值对之间的key是可以重复的。
- 在multimap中,通常按照key排序和惟一地标识元素,而映射的value存储与key关联的内容。key和value的类型可能不同,通过multimap内部的成员类型value_type组合在一起,value_type是组合key和value的键值对:typedef pair<const Key, T> value_type;
- 在内部,multimap中的元素总是通过其内部比较对象,按照指定的特定严格弱排序标准对key进行排序的。
- multimap通过key访问单个元素的速度通常比unordered_multimap容器慢,但是使用迭代器直接遍历multimap中的元素可以得到关于key有序的序列。
- multimap在底层用二叉搜索树(红黑树)来实现。
multimap的使用
void test_map2()
{
multimap<string, string> mdict;
mdict.insert(make_pair("sort", "排序"));
mdict.insert(make_pair("left", "左边"));
mdict.insert(make_pair("left", "右边"));
mdict.insert(make_pair("left", "不知道"));
// 遍历
for (auto& e : mdict)
{
cout << e.first << "=>" << e.second << endl;
}
cout << endl;
}
五、题目
前k个高频词
题目描述
解题思路
解题代码
class Solution {
public:
vector<string> topKFrequent(vector<string>& words, int k) {
// 用来记录次序的,本身就是按照字典序进行统计次数的
map<std::string, int> countmap;
for(const auto& e : words)
{
countmap[e]++;
}
// 用来排序的
multimap<int, string, greater<int>> sortmap;
// i - 2 love - 2 leetcode - 1 coding - 1
for(auto& e : countmap)
{
sortmap.insert(make_pair(e.second, e.first));
}
// 开辟一个字符串数组
vector<string> v;
multimap<int, string, greater<int>>::iterator it = sortmap.begin();
for(int i = 0; i < k; i++)
{
v.push_back(it->second);
++it;
}
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());
set<int>::iterator it1 = s1.begin();
set<int>::iterator it2 = s2.begin();
vector<int> v;
while(it1 != s1.end() && it2 != s2.end())
{
if(*it1 < *it2)
{
++it1;
}
else if(*it1 > *it2)
{
++it2;
}
else
{
v.push_back(*it1);
++it2;
++it1;
}
}
return v;
}
};