map和set
vector、list、deque……称为序列式容器 ——push系列 pop系列
map、set称为关联式容器 ——insert系列 erase系列
set
- set是按照一定次序存储元素的容器
- 在set中,元素的value也标识它(value就是key,类型为T),并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const),但是可以从容器中插入或删除它们。
- 在内部,set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
- set容器通过key访问单个元素的速度通常比unordered_set容器慢,但它们允许根据顺序对子集进行直接迭代。
- set在底层是用二叉搜索树(红黑树)实现的。
- T: set中存放元素的类型,实际在底层存储<value, value>的键值对。
- Compare:set中元素默认按照小于来比较
- Alloc:set中元素空间的管理方式,使用STL提供的空间配置器管理
set的使用举例
#include <set>
void TestSet()
{
// 用数组array中的元素构造set
int array[] = {
1, 3, 5, 7, 9, 2, 4, 6, 8, 0, 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
set<int> s(array, array + sizeof(array) / sizeof(array));
cout << s.size() << endl;
// 正向打印set中的元素,从打印结果中可以看出:set可去重
for (auto& e : s)
cout << e << " ";
cout << endl;
// 使用迭代器逆向打印set中的元素
for (auto it = s.rbegin(); it != s.rend(); ++it)
cout << *it << " ";
cout << endl;
// set中值为3的元素出现了几次
cout << s.count(3) << endl;
}
void test_set()
{
//排序+去重
set<int> s;
s.insert(1);
s.insert(5);
s.insert(4);
s.insert(6);
s.insert(8);
s.insert(0);
s.insert(15);
set<int>::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
auto ret = s.find(10); //O(logN)
// auto ret = find(s.begin(), s.end(), 10); //O(N)
if (ret != s.end())
{
s.erase(ret); //erase如果ret没在s中,那么用迭代器erase会出现报错(assert暴力检查),而用key_value erase就不会有那样的情况
}
for (const auto& e : s)
{
cout << e << " ";
}
cout << endl;
}
补充:
-
set中可以存储键值对,实例化set时,将set中元素类型设置为pair即可
-
set中的key是不能重复的
-
set中任意类型元素都可以存储,存储对象时,需要用户提供比较规则
-
set默认是升序,但是其内部默认不是按照大于比较,而是按照小于比较
扫描二维码关注公众号,回复: 14615316 查看本文章
multiset
- multiset是按照特定顺序存储元素的容器,其中元素是可以重复的。
- 在multiset中,元素的value也会识别它(因为multiset中本身存储的就是<value, value>组成的键值对,因此value本身就是key,key就是value,类型为T). multiset元素的值不能在容器中进行修改(因为元素总是const的),但可以从容器中插入或删除。
- 在内部,multiset中的元素总是按照其内部比较规则(类型比较)所指示的特定严格弱排序准则进行排序。
- multiset容器通过key访问单个元素的速度通常比unordered_multiset容器慢,但当使用迭代器遍历时会得到一个有序序列。
- multiset底层结构为二叉搜索树(红黑树)。
注意:
- multiset中再底层中存储的是<value, value>的键值对
- mtltiset的插入接口中只需要插入即可
- 与set的区别是,multiset中的元素可以重复,set是中value是唯一的
- 使用迭代器对multiset中的元素进行遍历,可以得到有序的序列
- multiset中的元素不能修改
- 在multiset中找某个元素,时间复杂度为O(logN)
- multiset的作用:可以对元素进行排序
补充:
- multiset在底层实际存储的是<k,k>的键值对
- multiset大部分接口与set的接口用法相同
multiset的使用
void test_multiset()
{
//排序+去重
multiset<int> s;
s.insert(1);
s.insert(5);
s.insert(4);
s.insert(6);
s.insert(8);
s.insert(8);
s.insert(0);
s.insert(15);
s.insert(6);
s.insert(6);
s.insert(6);
s.insert(6);
for (const auto& e : s)
{
cout << e << " ";
}
cout << endl;
auto pos = s.find(8);
while (pos != s.end() && *pos == 8)
{
cout << *pos << " ";
pos++;
}
cout << endl;
cout << s.count(1) << endl;
cout << s.count(6) << endl;
cout << s.count(8) << endl;
}
注:
- multiset中的find接口查找的是中序中第一个索要查找的值
- multiset中的count接口用于查看set中key出现的次数
map
- map是关联容器,它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
- 在map中,键值key通常用于排序和惟一地标识元素,而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同,并且在map的内部,key与value通过成员类型value_type绑定在一起,为其取别名称为pair:
typedef pair value_type; - 在内部,map中的元素总是按照键值key进行比较排序的。
- map中通过键值访问单个元素的速度通常比unordered_map容器慢,但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时,可以得到一个有序的序列)。
- map支持下标访问符,即在[]中放入key,就可以找到与key对应的value。
- map通常被实现为二叉搜索树(平衡二叉搜索树(红黑树))
key: 键值对中key的类型
T: 键值对中value的类型
Compare:比较器的类型,map中的元素是按照key来比较的,缺省情况下按照小于来比较,一般情况下(内置类型元素)该参数不需要传递,如果无法比较时(自定义类型),需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
Alloc:通过空间配置器来申请底层空间,不需要用户传递,除非用户不想使用标准库提供的空间配置器
注意:在使用map时,需要包含头文件。
void test_map1()
{
map<string, string> dict;
dict.insert(pair<string, string>("sort", "排序"));
dict.insert(make_pair("left", "左边"));
dict.insert(make_pair("right", "右边"));
map<string, string>::iterator it = dict.begin();
while (dict.end() != it)
{
cout << it->first << " " << it->second << endl;
it++;
}
cout << endl;
for (const auto& e : dict)
{
cout << e.first << " " << e.second << endl;
}
cout << endl;
}
void test_map2()
{
string str[] = {
"sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
map<string, int> countmap;
方法一:
//for (const auto& e : str)
//{
// auto ret = countmap.find(e);
// if (ret == countmap.end())
// countmap.insert(make_pair(e, 1));
// else
// {
// ret->second++;
// }
//}
//for (const auto& e : countmap)
//{
// cout << e.first << " " << e.second << endl;
//}
//方法二:
for (const auto& e : str)
{
countmap[e]++;
}
for (const auto& e : countmap)
{
cout << e.first << " " << e.second << endl;
}
}
应用统计单词次数
void test_map()
{
//统计单词次数
方法一
//string str[] = { "sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
//map<string, int> countmap;
//for (const auto& e : str)
//{
// auto ret = countmap.find(e);
// if (ret == countmap.end())
// countmap.insert(make_pair(e, 1));
// else
// {
// ret->second++; //ret->->second++;
// }
//}
//for (const auto& e : countmap)
//{
// cout << e.first << " " << e.second << endl;
//}
方法二:
//string str[] = { "sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
//map<string, int> countmap;
//for (const auto& e : str)
//{
// //pair<map<string, int>::iterator, int> ret = countmap.insert(make_pair(e, 1));
// auto ret = countmap.insert(make_pair(e, 1));
// //插入失败,表示e对应字符串已经在countmap中了,++次数
// if (ret.second == false)
// {
// ret.first->second++;
// }
//
//}
//for (const auto& e : countmap)
//{
// cout << e.first << " " << e.second << endl;
//}
//方法三:
string str[] = {
"sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
map<string, int> countmap;
for (const auto& e : str)
{
countmap[e]++;
}
for (const auto& e : countmap)
{
cout << e.first << " " << e.second << endl;
}
}
operator[]的应用:
void test_map2()
{
map<string, string> dict;
dict.insert(make_pair("sort", "排序"));
dict["string"] = "字符串"; //先插入("string",""),再修改value
dict["map"]; //先插入("map","")
dict["map"] = "地图"; //查找+修改
cout << dict["map"] << endl; //查找
}
注意:
- map中的operator[]:
-
- k在map中,insert插入失败,因为k已经有了,insert返回的pair会带出k在map中存储节点的迭代器,通过这个迭代器,可以拿到k对应的value的值进行返回
-
- k不在map中,insert插入成功,插入的值是pair<k,value()>,insert返回值会带出刚插入的k所在节点迭代器,通过这个迭代器,可以拿到k对应的value值进行返回
总结map的operator[]的特征:
- k不存在,插入默认的构造函数生成缺省值的value的pair<k,v()>
- k存在,返回k对应的value的值
- operator[]用于插入、查找、修改
补充:
- map和set底层结构都是红黑树,而其底层红黑树在实现时并没有区分是存k模型还是KV 模型
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和map的唯一不同就是:map中的key是唯一的,而multimap中key是可以重复的。
multimap的使用
multimap中的接口可以参考map,功能都是类似的。
注意:
- multimap中的key是可以重复的。
- multimap中的元素默认将key按照小于来比较
- multimap中没有重载operator[]操作(找到key之后,但是无法确定用哪个key对应的value值(因为multimap中key是可以重复的))。
- 使用时与map包含的头文件相同:
void test_multimap()
{
multimap<string, string> dict;
dict.insert(make_pair("sort", "排序1"));
dict.insert(make_pair("sort", "排序2"));
dict.insert(make_pair("sort", "排序3"));
for (const auto& e : dict)
{
cout << e.first << " " << e.second << endl;
}
}
补充:multiamp中的find接口查找的是中序中第一个索要查找的k值
红黑树模拟实现STL中的map与set
红黑树的迭代器
begin()与end():
STL明确规定,begin()与end()代表的是一段前闭后开的区间,而对红黑树进行中序遍历后,可以得到一个有序的序列,因此:begin()可以放在红黑树中最小节点(即最左侧节点)的位置,end()放在最大节点(最右侧节点)的下一个位置即nullptr
注:在STL库中红黑树的迭代器实现:begin()可以放在红黑树中最小节点(即最左侧节点)的位置,end()放在最大节点(最右侧节点)的下一个位置,对end()位置的迭代器能找最后一个元素,将end()放在头结点的位置
operator++()(对于迭代器it)
- 如果it指向节点的右子树不为空,下一个就++到右子树中序第一个节点,也就是右子树的左节点
- 如果it指向节点的右子树为空,下一个++要访问的节点是,沿着it指向节点到根节点的路径中,孩子是父亲做的那个父亲节点
operator–()(对于迭代器it)
- 如果it指向节点的左子树不为空,下一个就–到左子树中序第最后个节点,也就是左子树的右节点
- 如果it指向节点的左子树为空,下一个–要访问的节点是,沿着it指向节点到根节点的路径中,孩子是父亲做的那个父亲节点
改造红黑树
注意(在红黑树中):
- KeyOfT: 通过value来获取key的一个仿函数类
- T: 如果是map,则为pair<K, V>; 如果是set,则为k
- K:k为key的类型,
红黑树的代码(改装后)
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<time.h>
using namespace std;
enum Color
{
RED,
BLACK
};
template<class T>
struct RBTreeNode
{
RBTreeNode(const T& data)
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_data(data)
,_col(RED)
{
}
RBTreeNode<T>* _left;
RBTreeNode<T>* _right;
RBTreeNode<T>* _parent;
T _data;
Color _col;
};
template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
typedef RBTreeIterator<T, Ref, Ptr> Self;
typedef RBTreeNode<T> Node;
RBTreeIterator(Node* node = nullptr)
:_node(node)
{
}
Node* _node=nullptr;
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator==(const Self& it)const
{
return _node == it._node;
}
bool operator!=(const Self& it)const
{
return _node != it._node;
}
Self& operator++()
{
Node* cur = _node;
if (cur && cur->_right)
{
Node* n = cur->_right;
while (n->_left)
{
n = n->_left;
}
//*this = Self(n);
_node = n;
}
else
{
cur = _node;
Node* parent =cur ->_parent;
Node* n = nullptr;
if (parent->_left == cur)
{
n = parent;
}
else
{
while (parent&&parent->_right == cur)
{
cur = parent;
parent = cur->_parent;
}
n = parent;
}
_node = n;
}
return *this;
}
Self operator++(int)
{
Self it(_node);
if (_node->_right)
{
// 右子树中序第一个节点,也就是右子树的最左节点
Node* subLeft = _node->_right;
while (subLeft->_left)
{
subLeft = subLeft->_left;
}
_node = subLeft;
}
else
{
// 当前子树已经访问完了,要去找祖先访问,沿着到根节点的路径往上走,
// 找孩子是父亲左的那个父亲节点
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && parent->_right == cur)
{
cur = parent;
parent = parent->_parent;
}
_node = parent;
}
return it;
}
Self& operator--()
{
if (_node->_left)
{
Node* subLeft = _node->_left;
while (subLeft->_right)
{
subLeft = subLeft->_right;
}
_node = subLeft;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && parent->_left == cur)
{
cur = parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
Self operator--(int)
{
Self it(_node);
if (_node->_left)
{
Node* subLeft = _node->_left;
while (subLeft->_right)
{
subLeft = subLeft->_right;
}
_node = subLeft;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && parent->_left == cur)
{
cur = parent;
parent = parent->_parent;
}
_node = parent;
}
return it;
}
};
template<class K, class T, class KeyOfT>
class RBTree
{
typedef RBTreeNode<T> Node;
public:
typedef RBTreeIterator<T, T&, T*> iterator;
typedef RBTreeIterator<T, T&, T*> reverse_iterator;
typedef RBTreeIterator<T, const T&, const T*> const_iterator;
typedef RBTreeIterator<T, const T&, const T*> const_reverse_iterator;
iterator begin()
{
Node* n = _root;
while (n && n->_left)
{
n = n->_left;
}
return n;
}
iterator end()
{
return nullptr;
}
const_iterator begin()const
{
Node* n = _root;
while (n && n->_left)
{
n = n->_left;
}
return n;
}
const_iterator end()const
{
return nullptr;
}
reverse_iterator rbegin()
{
Node* n = _root;
while (n && n->_right)
{
n = n->_right;
}
return n;
}
reverse_iterator rend()
{
return nullptr;
}
const_reverse_iterator rbegin()const
{
Node* n = _root;
while (n && n->_right)
{
n = n->_right;
}
return n;
}
const_reverse_iterator rend()const
{
return nullptr;
}
pair<iterator,bool> Insert(const T& data)
{
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return make_pair(_root, true);
}
Node* cur = _root;
Node* parent = cur;
KeyOfT kot;
while (cur)
{
if (kot(cur->_data)>kot(data))
{
parent = cur;
cur = cur->_left;
}
else if (kot(cur->_data) < kot(data))
{
parent = cur;
cur = cur->_right;
}
else
{
return make_pair(cur, false);
}
}
// 新增节点,颜色是红色,可能破坏规则3,产生连续红色节点
cur = new Node(data);
Node* newnode = cur;
if (kot(parent->_data) > kot(data))
{
parent->_left = cur;
cur->_parent = parent;
}
else
{
parent->_right = cur;
cur->_parent = parent;
}
// 控制近似平衡
while (parent && parent->_col == RED)
{
Node* grandparent = parent->_parent;
if (grandparent->_left == parent)
{
Node* uncle = grandparent->_right;
// 情况一:uncle存在且为红,进行变色处理,并继续往上更新处理
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandparent->_col = RED;
cur = grandparent;
parent = cur->_parent;
}
// 情况二+三:uncle不存在,或者存在且为黑,需要旋转+变色处理
else
{
// 情况二:单旋+变色
if (cur == parent->_left)
{
RotateR(grandparent);
grandparent->_col = RED;
parent->_col = BLACK;
}
// 情况三:双旋 + 变色
else
{
RotateL(parent);
RotateR(grandparent);
cur->_col = BLACK;
grandparent->_col = RED;
}
break;
}
}
else// (parent == grandfather->_right)
{
Node* uncle = grandparent->_left;
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandparent->_col = RED;
cur = grandparent;
parent = cur->_parent;
}
else
{
if (cur == parent->_right)
{
RotateL(grandparent);
grandparent->_col = RED;
parent->_col = BLACK;
}
else
{
RotateR(parent);
RotateL(grandparent);
cur->_col = BLACK;
grandparent->_col = RED;
}
break;
}
}
}
_root->_col = BLACK;
return make_pair(newnode, true);
}
void RotateR(Node* parent)
{
if (parent == nullptr)
return;
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
Node* cur = parent->_parent;
subL->_right = parent;
if (parent == _root)
{
_root = subL;
subL->_parent = nullptr;
parent->_parent = subL;
}
else
{
if (cur->_left == parent)
{
cur->_left = subL;
subL->_parent = cur;
parent->_parent = subL;
}
else
{
cur->_right = subL;
subL->_parent = cur;
parent->_parent = subL;
}
}
}
void RotateL(Node* parent)
{
if (parent == nullptr)
return;
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* cur = parent->_parent;
subR->_left = parent;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
parent->_parent = subR;
}
else
{
if (cur->_left == parent)
{
cur->_left = subR;
subR->_parent = cur;
parent->_parent = subR;
}
else
{
cur->_right = subR;
subR->_parent = cur;
parent->_parent = subR;
}
}
}
bool CheckRedRed(Node* root)
{
if (root == nullptr)
return true;
if (root->_col == RED && root->_parent->_col == RED)
return false;
return CheckRedRed(root->_left) && CheckRedRed(root->_right);
}
bool CheckBlackNum(Node* root, int blacknum, int benchmark)
{
if (root == nullptr)
{
if (blacknum != benchmark)
return false;
return true;
}
if (root->_col == BLACK)
blacknum++;
return CheckBlackNum(root->_left, blacknum, benchmark) && CheckBlackNum(root->_right, blacknum, benchmark);
}
bool IsBalance()
{
if (_root == nullptr)
return true;
if (_root->_col == RED)
return false;
int benchmark = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
benchmark++;
cur = cur->_left;
}
int blacknum = 0;
return CheckRedRed(_root->_left) && CheckRedRed(_root->_right) && CheckBlackNum(_root, blacknum, benchmark);
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void _InOrder(Node* root)
{
KeyOfT kot;
if (root == nullptr)
return;
_InOrder(root->_left);
cout << kot(root->_data) << " ";
_InOrder(root->_right);
}
private:
Node* _root=nullptr;
};
set的代码
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include"RBTree.h"
namespace lc
{
template<class K>
class set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
typedef RBTree<K, K, SetKeyOfT> RBT;
typedef typename RBT::iterator iterator;
typedef typename RBT::reverse_iterator reverse_iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
reverse_iterator rbegin()
{
return _t.rbegin();
}
reverse_iterator rend()
{
return _t.rend();
}
pair<iterator, bool> insert(const K& key)
{
return _t.Insert(key);
}
private:
RBT _t;
};
}
map的代码
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include"RBTree.h"
namespace lc
{
template<class K,class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<const K,V>& kv)
{
return kv.first;
}
};
public:
typedef RBTree<K, pair<const K,V>, MapKeyOfT> RBT;
typedef typename RBT::iterator iterator;
typedef typename RBT::reverse_iterator reverse_iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
reverse_iterator rbegin()
{
return _t.rbegin();
}
reverse_iterator rend()
{
return _t.rend();
}
pair<iterator, bool> insert(const pair<const K,V>& kv)
{
return _t.Insert(kv);
}
V& operator[](const K& key)
{
pair<iterator, bool> it = insert(make_pair(key, V()));
return (it.first)->second;
}
private:
RBT _t;
};
}
补充:
拷贝构造、赋值拷贝、析构函数、查找接口(可见以下文章)
【手撕STL】红黑树
【手撕STL】AVL树
【手撕STL】二叉搜索树