目录
- [1. 关联式容器map与set](#1. 关联式容器map与set)
- [2. set与multiset的接口与使用](#2. set与multiset的接口与使用)
-
- [2.1 set的接口与使用](#2.1 set的接口与使用)
-
- [2.1.1 成员函数](#2.1.1 成员函数)
- [2.1.2 迭代器](#2.1.2 迭代器)
- [2.1.3 容量相关](#2.1.3 容量相关)
- [2.1.4 修改相关](#2.1.4 修改相关)
- [2.1.5 查找，计数与补充](#2.1.5 查找，计数与补充)
- [2.2 multiset的接口与使用](#2.2 multiset的接口与使用)
- [3. map与multimap的接口与使用](#3. map与multimap的接口与使用)
-
- [3.1 map的接口与使用](#3.1 map的接口与使用)
-
- [3.1.1 map的使用补充](#3.1.1 map的使用补充)
- [3.1.2 插入与operator[]](#3.1.2 插入与operator[])
- [3.2 multimap接口与使用](#3.2 multimap接口与使用)
- [4. map与set相关练习](#4. map与set相关练习)
-
- [4.1 随机链表的复制（map实现）](#4.1 随机链表的复制（map实现）)
- [4.2 前K个高频单词](#4.2 前K个高频单词)
- [4.3 两个数组的交集](#4.3 两个数组的交集)
1. 关联式容器map与set
- 我们在之前的学习中，已经学习了解了许多的STL库中的容器，诸如vector（顺序表），list（链表）,deque（双端队列），这类容器的底层数据结构都为线性序列。
- 而今天我们所学习的map与set，则是一种区别于此前线性数据结构，叫做关联式数据结构的新容器。
- map与set的底层数据结构为红黑树，这一种平衡二叉树，此类关联式数据结构其中存储的数据为<key , value>模型。
- 这类数据结构，其可以通过键值迅速找到对应的数据，之所以其支持此种数据存储方式，是因为它的搜索效率相较于线性数据结构具有更高。
2. set与multiset的接口与使用
2.1 set的接口与使用
2.1.1 成员函数
- <1> set容器其的底层为一颗红黑树
<2> 其数据存储节点所存的值为单参数数据，即key模型
<3> set中不允许存在值相同的数据结点。
- 构造函数
cpp
复制代码
//迭代器区间构造
template<class InputIterator>
set(InputIterator first, InputIterator last);
//拷贝构造
set(const set& x);
- 赋值运算符重载
cpp
复制代码
set& operator=(const set& x);
2.1.2 迭代器
- <1> set支持迭代器遍历与范围for
<2> 对其进行正向遍历会得到升序的数据序列，逆向遍历会得到降序的数据序列
<3> 将数据插入至set中，并获取遍历得到的数据序列，等于对一组数据进行去重与排序
<4> C++算法库中存在有去重算法unique，向其传递一段迭代器区间，其会这段区间内的数据进行去重，前提为区间内的数据有序。
cpp
复制代码
#include <iostream>
using namespace std;
#include <set>
int main()
{
int arr[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
set<int> s;
for (auto e : arr)
{
s.insert(e);
}
//正向遍历，升序
for (auto it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
//逆向遍历，降序
for (auto rit = s.rbegin(); rit != s.rend(); rit++)
{
cout << *rit << " ";
}
cout << endl;
return 0;
}
cpp
复制代码
//非const迭代器
//正向迭代器
iterator begin();
iterator end();
//反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();
//const迭代器
const_iterator cbegin();
const_iterator cend();
const_reverse_iterator crbegin();
const_reverse_iterator crend();
2.1.3 容量相关
cpp
复制代码
//判空
bool empty() const;
//数据长度
size_t size();
//最大存储数据个数
size_t max_size();
2.1.4 修改相关
- 插入
cpp
复制代码
//插入一个值
pair<iterator, bool> insert(const value_type& val);
//在指定迭代器位置插入一个值，返回新插入元素的迭代器
iterator insert(iterator pos, const value_type& val);
//插入一段迭代器区间
void insert(iterator first, iterator last);
- inset的值插入方式，会返回一个pair类型的值。
- pair为C++库中定义的一个类，这个类是将两个指定的不同数据类型的值进行了封装
- 存储到的两个数据在pair类型中分别是名为
first与second的成员变量，第一个insert函数的返回值pair
<1> 当新插入元素在set中没有值重复结点时，pair返回值中的second为true，first为返回新插入元素结点的迭代器
<2> 当set存在相同值得结点时，pair返回值中得second为false，first为set中相同值结点得迭代器
- set中数据存储结点的key值不可以被改变，会破坏红黑树的结构
- 删除
cpp
复制代码
//删除一个指定迭代器位置的数据
void erase(iterator pos);
//从set中删除一个为指定值的结点
size_t erase(const value_type& val);
//删除一段指定的迭代器区间
void erase(iterator first, iterator last);
- 删除指定迭代器位置的数据时，若迭代器不存在，会发生报错
- 删除set中key值为指定值的结点时，若结点不存在，不会发生报错
2.1.5 查找，计数与补充
- 查找
cpp
复制代码
iterator find(const value_type& val) const;
- 查找set中key值为指定值的结点，若找到，返回此结点的迭代器，若未找到，返回end()。
- 计数
cpp
复制代码
size_t count(const value_type& val) const;
- 统计set中key值为指定值结点的个数并返回，set中此接口是为了与multiset做统一。
- lower_bound与upper_bound
cpp
复制代码
//指定一段区间，获得set中标识此段区间内的迭代器
//左边界
iterator lower_bound(const value_type& val) const;
//右边界
iterator upper_bound(const value_type& val) const;
- lower_bound获取区间左边界迭代器，会返回值大于等于val的迭代器
- upper_bound获取区间右边界迭代器，会返回值大于val的迭代器
- 区间边界需要左闭右开[left，right)，这与迭代器的遍历方式相关
2.2 multiset的接口与使用
- multiset的接口与使用方式都和set相同 ，只是multiset支持key值冗余，即相同值结点的插入
- 在查找时，若multiset中存在着多个key值相同的结点，其会优先返回第一个查找到的key值结点
3. map与multimap的接口与使用
3.1 map的接口与使用
3.1.1 map的使用补充
- <1> map的接口与set大体相同，两者之间的区别为其中数据存储结点，其存储的数据有所不同，set中存储key类型的结点，而map中存储<key，value>类型的结点。
<2> 并因此，map一些接口的使用方式也set有所区别。
<3> 因为存储数据模型的原因，其的查找，数据结构排列都是以key值为依照
- <1> map中存储数据结点都为pair类型的变量，first做key值，second做value
<2> key值不可改变，而value可以修改
<3> map容器其数据结点的value_type为pair<const key, value>
- map的迭代器，重载了operator->运算符，因此，可以使用
it->first，it->second的方式访问数据结点内部存储的值。
3.1.2 插入与operator[]
- 插入
cpp
复制代码
//插入一个值
pair<iterator, bool> insert(const value_type& val);
//在指定迭代器位置插入一个值
iterator insert(iterator pos, const value_type& val);
//插入一段迭代器区间内的值
template<class InputIterator>
void insert (InputIterator first, InputIterator last);
- pair类型对象的构造，可以采用传递有名对象与匿名对象的方式，除此之外，C++库中还存在着一个函数
make_pair可以帮助我们构造一个指定pair类型的对象，方便我们的使用
- C++11中，支持了多参数构造函数的隐式类型转换
cpp
复制代码
//make_pair的内部实现，根据传递参数推导类型构造pair对象
template <class T1,class T2>
pair<T1,T2> make_pair (T1 x, T2 y)
{
return ( pair<T1,T2>(x,y) );
}
//方式1：
insert(make_pair(10, 10));
//方式2：多参数构造函数隐式类型转换方式
inset({10, 10});
- operator[] 运算符重载
- 我们传递key值，会返回map中key值所对应结点的value，且为引用类型，可修改。
cpp
复制代码
value_type& operator[](const key& k);
//内部实现等同于
*((this->insert(make_pair(k, map_value_type())).first)).second
//简单模拟实现
V& operator[](const key& k)
{
pair<const key, V> ret = insert(make_pair(k, V()));
return ret.first->second;
}
- insert值插入的返回值为pair<iterator，bool>，取用此pair的first，即插入元素的iterator，并以此迭代器访问其对应结点的second
cpp
复制代码
//使用operator[]可以直接插入统计修改，对应key值的value
int main()
{
vector<string> v = {"苹果", "西瓜", "菠萝", "菠萝", "西瓜" ,"苹果" ,"苹果" };
map<string, int> m;
for (auto e : v)
{
m[e]++;
}
//等同于
for(auto : v)
{
//插入
pair<iterator, bool> ret = m.insert(e).first;
//存在，次数++
if(ret.second == false)
{
(ret.first)->second++;
}
}
for (auto e : m)
{
cout << e.first << " : " << e.second << endl;
}
return 0;
}
3.2 multimap接口与使用
- multimap与map的关系与multiset与set的关系类似，multimap也支持key冗余，在其他接口的使用上，与map相同。
- multimap不支持operator[]。
4. map与set相关练习
4.1 随机链表的复制（map实现）
- 题目链接：
随机链表的复制
- 思路：映射关系的建立，前提：随机指针指向的是链表中的结点
cpp
复制代码
class Solution
{
public:
Node* copyRandomList(Node* head)
{
//记录映射关系，原链表与拷贝链表
//随机指针都指向链表本身的结点
//以原链表的随机指针指向结点，找到对应的拷贝结点
//创建拷贝链表，并建立映射关系
Node* cur = head;
Node* newhead = nullptr;
Node* newtail = nullptr;
map<Node*, Node*> m;
while(cur)
{
Node* newnode = new Node(cur->val);
if(newhead == nullptr)
{
newhead = newnode;
newtail = newhead;
}
else
{
newtail->next = newnode;
newtail = newtail->next;
}
m[cur] = newnode;
cur = cur->next;
}
//根据映射关系，调整随机链表
cur = head;
while(cur)
{
//当前拷贝结点的随机指针，指向原链表随机指针指向结点的映射结点
m[cur]->random = m[cur->random];
cur = cur->next;
}
return newhead;
}
};
4.2 前K个高频单词
- 题目信息：
- 题目链接：
前K个高频单词
- 思路：数据小于32为插入排序，大于32为归并排序
cpp
复制代码
class Solution
{
public:
struct comp1
{
bool operator()(const pair<string, int>& left, const pair<string, int>& right)
{
return (left.second > right.second) || (left.second == right.second && left.first < right.first);
}
};
struct comp2
{
bool operator()(const pair<string, int>& left, const pair<string, int>& right)
{
//归并排序，稳定，不会打乱map中的字典序
//11归，22归，44归，...
return left.second > right.second;
}
};
vector<string> topKFrequent(vector<string>& words, int k)
{
vector<string> ret;
//向map中插入计数
map<string, int> m;
for(auto e : words)
{
m[e]++;
}
//向vector中插入结点数据并排序
vector<pair<string, int>> v(m.begin(), m.end());
//进行排序，快排（不稳定排序），归并（稳定排序）
//pair的默认排序方式
//构建的匿名对象comp()
//sort(v.begin(), v.end(), comp1());
stable_sort(v.begin(), v.end(), comp2());
//map排序为字典序的升序
//根据value排降序
for(auto it = v.begin(); it != v.begin() + k; it++)
{
ret.push_back(it->first);
}
return ret;
}
};
4.3 两个数组的交集
- 题目信息：
- 题目链接：
两个数组的交集
- 思路：
<1> set去重查找
<2> 同步算法
- 同步算法： （应用：云存储同步）
<1> 将两方数据分别插入至一个set去重排序，可以同时找到数据的交集与差集
<2> 从开始比对，小的为差集，相等的为交集，因为二者都有序，那么小的一定是差集
<3> 若为差集，小的++，若为交集，二者同时++
cpp
复制代码
//方法1：
class Solution
{
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
{
vector<int> ret;
//插入去重，不能重复
set<int> s1;
set<int> s2;
for(auto e : nums1)
{
s1.insert(e);
}
for(auto e : nums2)
{
s2.insert(e);
}
for(auto e : s1)
{
if(s2.count(e))
{
ret.push_back(e);
}
}
return ret;
}
};
//方法2：
class Solution
{
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
{
vector<int> ret;
set<int> s1(nums1.begin(), nums1.end());
set<int> s2(nums2.begin(), nums2.end());
//同步算法
auto it1 = s1.begin();
auto it2 = s2.begin();
while(it1 != s1.end() && it2 != s2.end())
{
if(*it1 == *it2)
{
ret.push_back(*it1);
it1++;
it2++;
}
else if(*it1 < *it2)
{
it1++;
}
else
{
it2++;
}
}
return ret;
}
};