手撕STLmap和set
Posted The August
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手撕STLmap和set相关的知识，希望对你有一定的参考价值。
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默认是升序，但是其内部默认不是按照大于比较，而是按照小于比较
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;
以上是关于手撕STLmap和set的主要内容，如果未能解决你的问题，请参考以下文章