目录
1. 关联式容器
STL中的部分容器，比如：vector、list、deque、forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。
2. 键值对
用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代
表键值，value表示与key对应的信息。比如：现在要建立一个英汉互译的字典，那该字典中必然
有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该单词，在词典中就可以找到与其对应的中文含义。
SGI-STL中关于键值对的定义：
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)
{}
};3. 树形结构的关联式容器
根据应用场景的不桶，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结
构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使
用平衡搜索树(即红黑树)作为其底层结构，容器中的元素是一个有序的序列。下面一依次介绍每一
个容器。
3.1 set
3.1.1 set的介绍
1. set是按照一定次序存储元素的容器
2. 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。
set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
4. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对
子集进行直接迭代。
5. set在底层是用二叉搜索树(红黑树)实现的。
注意：
1. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放
value，但在底层实际存放的是由<value, value>构成的键值对。
2. set中插入元素时，只需要插入value即可，不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素，可以得到有序序列（默认是升序，如果要排降序，要控制第二个模板参数 Compare，将它实例化为 greater<T> 即可。
5. set中的元素默认按照小于来比较（第二个模板参数 Compare 的缺省是 less<T>）
6. set中查找某个元素，时间复杂度为：logn
7. set中的元素不允许修改
8. set中的底层使用二叉搜索树(红黑树)来实现
3.1.2 set的使用
1. set的模板参数列表
T: set中存放元素的类型，实际在底层存储<value, value>的键值对。
Compare：set中元素默认按照小于来比较
Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理
2. set的构造
3. set的迭代器
4. set的容量
5. set修改操作
注意 insert 函数：
pair<iterator,bool> insert (const value_type& val);
它返回的是一个 pair ，它的功能是：
iterator：如果插入成功，iterator 指向新插入的结点，如果失败，指向已经存在 set 的结点
bool ：如果插入成功，返回 true，如果失败返回 false
6. 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;
s.insert(1);
s.insert(1);
s.insert(1);
// 正向打印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;
// 删除\查找操作
// 在pos迭代器位置删除
auto pos = s.find(3); // 如果没有找到，返回s.end();
if(pos != s.end())
s.erase(pos);
auto pos = s.find(3);（O(logN))
auto pos = find(s.begin(),s.end(),3);(O(N))
// count 成员函数，对于 set 用于查找，找到返回1，否则返回0
// 对于 muitiset 返回 key 出现了几次
if(s.count(3))
{
cout << "找到了" << endl;
}
// 直接删除,若该值不存在，不报错
s.erase(5);
}
multiset:和 set 在同一头文件中，与set的唯一区别是允许存在重复元素的容器。muitiset 的 find 函数返回中序遍历的第一个 key。count 函数、equal_range 函数都是为 multiset 设计的，对 set 没有多大意义。
lower_bound:
返回第一个不小于 key 的元素
如果所有元素都小于 key，返回
end()
upper_bound:
返回第一个大于 key 的元素
如果所有元素都不大于 key，返回
end()
equal_range:(寻找相同元素区间）
返回一个 pair，包含
lower_bound和upper_bound的结果对于
set，如果 key 存在，range.first指向该元素，range.second指向下一个元素，对于 multiset ，range.first指向第一个相同元素，range.second指向最后一个相同元素的下一个如果 key 不存在，
range.first和range.second相同，都指向第一个大于 key 的元素
3.2 map
3.2.1 map的介绍
1. map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
2. 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的
内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型
value_type绑定在一起，为其取别名称为pair: typedef pair<const key, T> value_type;
3. 在内部，map中的元素总是按照键值key进行比较排序的。（默认是升序，如果要排降序，要控制第二个模板参数 Compare，将它示例化为 greater<T> 即可。）
4. map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序
对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
5. map支持下标访问符，即在 [ ] 中放入key，就可以找到与key对应的value。
6. map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。
3.2.2 map的使用
1. map的模板参数说明
key: 键值对中key的类型
T： 键值对中value的类型
Compare: 比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比
较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户
自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的
空间配置器
2. map的构造
3. map的迭代器
4. map的容量与元素访问
问题：当key不在map中时，通过operator获取对应value时会发生什么问题？
注意：在元素访问时，有一个与operator[]类似的操作at()(该函数不常用)函数，都是通过
key找到与key对应的value然后返回其引用，不同的是：当key不存在时，operator[]用默认
value与key构造键值对然后插入，返回该默认value，at()函数直接抛异常。
5. map中元素的修改
#include <string>
#include <map>
void TestMap()
{
map<string, string> m;
// 向map中插入元素的方式：
// 将键值对<"peach","桃子">插入map中，用pair直接来构造键值对
// pair 是结构体类型
m.insert(pair<string, string>("peach", "桃子")); // 匿名结构体对象
// 将键值对<"peach","桃子">插入map中，用make_pair函数来构造键值对
// make_pair函数返回匿名结构体对象
m.insert(make_pair("banan", "香蕉"));
// C++11 支持多参数的构造函数隐式类型转换
m.insert({"watermelon", "西瓜"});
// 再插入一个 key 相同而 value 不相同的pair
// 此时既不插入，也不覆盖
m.insert({"watermelon", "XXXX"});
// 借用operator[]向map中插入元素
/*
operator[]的原理是：
用<key, T()>构造一个键值对，然后调用insert()函数将该键值对插入到map中
如果key已经存在，插入失败，insert函数返回该key所在位置的迭代器
如果key不存在，插入成功，insert函数返回新插入元素所在位置的迭代器
operator[]函数最后将insert返回值键值对中的value返回
*/
// 将<"apple", "">插入map中，插入成功，返回value的引用，
//将“苹果”赋值给该引用结果，
m["apple"] = "苹果";
// key不存在时抛异常
//m.at("waterme") = "水蜜桃";
cout << m.size() << endl;
// 用迭代器去遍历map中的元素，可以得到一个按照key排序的序列
auto it = m.begin();
while(it != m.end())
{
cout << it->first << "---->" << it->second << endl;
it++;
}
for (auto& e : m)
cout << e.first << "--->" << e.second << endl;
cout << endl;
// map中的键值对key一定是唯一的，如果key存在将插入失败
auto ret = m.insert(make_pair("peach", "桃色"));
if (ret.second)
cout << "<peach, 桃色>不在map中, 已经插入" << endl;
else
cout << "键值为peach的元素已经存在：" << ret.first->first << "--->"
<< ret.first->second <<" 插入失败"<< endl;
// 删除key为"apple"的元素
m.erase("apple");
if (1 == m.count("apple"))
cout << "apple还在" << endl;
else
cout << "apple被吃了" << endl;
}使用 map 统计 key 出现的次数
// 统计次数
string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
map<string, int> countMap;
//for (auto e : arr)
//{
// auto it = countMap.find(e);
// if (it == countMap.end())
// {
// countMap.insert(make_pair(e, 1));
// }
// else
// {
// it->second++;
// }
//}
for (auto e : arr)
{
countMap[e]++;
}
for (const auto& kv : countMap)
{
cout << kv.first << ":" << kv.second << endl;
}operator[ ] 的原理
operator[]的原理是：
用<key, T()>构造一个键值对，然后调用insert()函数将该键值对插入到map中
- 如果key已经存在，插入失败，insert函数返回该key所在位置的迭代器
- 如果key不存在，插入成功，insert函数返回新插入元素所在位置的迭代器
operator[]函数最后将insert返回值键值对中的value返回
首先明确 insert 函数的返回值：
pair<iterator,bool>：
如果待插入的 key 不存在，则返回新插入结点所在位置的迭代器和 true，如果待插入的 key 已经存在，insert 不会覆盖，返回 key 结点所在位置的迭代器和 false。
operator[ ] 函数大致是这样实现的：
mapped_type& operator[](const key_type& k)
{
pair<iterator,bool> ret = insert(make_pair(k,mapped_type());
return ret.first->second;
}muitimap 与 map 大致相同，但是 multimap 允许存在重复元素。
4、map 和 set 的模拟实现
4.1 STL 源码分析
1、rb_tree 第一个和第二个模板参数：class key，class Value
从 STL 源码可以看出：红黑树中实际存储的是第二个模板参数 class Value 类型的数据，该类型在set 中是 value_type ( typedef rb_tree<key_type,value_type...... 也就是 set 的第一个模板参数 class Key （ typedef Key value_type）；在 map 中是 pair<const Key, T> 。而红黑树第一个模板参数是为像 find 这样的算法获取 key 的类型而准备的。
2、rb_tree 第三个模板参数：KeyOfValue
在 map 的树型结构中，实际存储的是 pair<const Key, T>，insert 函数的参数是 const Value& data，在插入时会面临 pair 和 pair 比较的问题，虽然可以直接使用 data.first 比较，但 set 怎么办？set 中存储的只是 key。而库里面 pair 自己实现的比较函数又不符合预期。为了解决这个问题，在 map 中实现了一个内部结构体，这个内部结构体实现了 operator（）：
struct MapKeyOfT
{
const k& operator()(const pair<K,V>& kv)
{
return kv.first;
}
};在 rb_tree 中，只需要创建一个 KeyOfValue 的对象 kot ，给它转递 pair ，它就会返回 pair 的 first。为了统一，set 也要实现一个这样的内部结构体（完全是为了将就 map，它没什么用）。KeyOfValue 的工作只是把 pair 的 first 取出，至于 first 如何比较由第四个模板参数决定。最好不要把 KeyOfValue 和 compare 的工作和在一起，因为比如 find 函数要面临 pair 和 key 比较。
struct SetKeyOfT
{
const k& operator()(const K& key)
{
return key;
}
};bool Insert(const T& data)
{
// ...
KeyOfT kot;
while (cur)
{
if (kot(cur->_data) < kot(data))
{
parent = cur;
cur = cur->_right;
}
else if (kot(cur->_data) > kot(data))
// ...
}4.2 迭代器的实现
迭代器的核心操作：
auto it = s.begin();
while(it != s.end())
{
cout << *it << endl;
++it;
}对于 map 和 set 而言，迭代器肯定走的是中序遍历，begin() 应该返回树形结构的最左侧的结点，即最小元素所在的结点，而 end() 应该返回最右侧的结点，即最大元素所在的结点。最困难的是对于迭代器的 ++ 操作。
iterator begin()
{
Node* leftMin = _root;
// 注意如果树为空的情况
while (leftMin && leftMin->_left)
{
leftMin = leftMin->_left;
}
return iterator(leftMin);
}
iterator end()
{
return iterator(nullptr);
}operator++()
不能用递归的方法走中序遍历，否则只能一次性遍历整个树型结构。也不能借助栈实现非递归。
it 从begin()开始，即从最左侧的结点开始，找到“下一个结点”的策略：
- 如果右树不为空，访问右树的最左结点
- 如果右树为空，下一个访问的结点是通过 parent 指针一路向上，直到某个结点是父结点的左孩子，那个父结点就是下一个要访问的结点。
- 如果迭代器为空，说明已经遍历完成
场景示例：
template<class T>
struct __TreeIterator
{
typedef RBTreeNode<T> Node;
typedef __TreeIterator<T> Self;
Node* _node;
__TreeIterator(Node* node)
:_node(node)
{}
T& operator*()
{
return _node->_data;
}
T* operator->()
{
return &_node->_data;
}
bool operator!=(const Self& s)
{
return _node != s._node;
}
Self& operator--();
Self& operator++()
{
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)
{
if (cur == parent->_left)
{
break;
}
else
{
cur = cur->_parent;
parent = parent->_parent;
}
}
_node = parent;
}
return *this;
}
};
operator--()
要实现operator--()，只需要将 ++ 的策略“反过来”，即左变成右，右边从左：
- 如果左树不为空，访问左树的最左结点
- 如果左树为空，下一个访问的结点是通过 parent 指针一路向上，直到某个结点是父结点的右孩子，那个父结点就是下一个要访问的结点。
- 如果迭代器为空，说明已经遍历完成
stl 为了实现关联式容器简单，在红黑树的实现中增加一个头结点，因为根节点必须为黑色，为了
与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft
域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点，如下：
map 和 set 的迭代器和 const 迭代器
set 的迭代器
在 set 中，因为 set 的 key 值不允许被修改，所以不管是 iterator 还是 const iterator 都是树的 const iterator 迭代器：
typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator; typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;而树中对树的迭代器的内嵌声明：
template<class K, class T, class KeyOfT> struct RBTree { typedef RBTreeNode<T> Node; public: // 同一个类模板，传的不同的参数实例化出的不同类型 typedef __TreeIterator<T, T*, T&> iterator; typedef __TreeIterator<T, const T*, const T&> const_iterator; ...const_iterator 对 T 类型多了 const 修饰，使得 __TreeIterator 的 operator* 返回的是 const T&，也就不能通过 *it 的方式对 key 进行修改。
set 的 begin 方法和 end 方法都只有 const 版本：
const_iterator begin() const { return _t.begin(); } const_iterator end() const { return _t.end(); }const 成员函数将类的数据成员都视为 const 类型，所以上面函数中 _t 都是 const 类型，既然 _t 是 const 类型，而树里的 begin 方法既有 const 的，也有非 const 的，const _t 自然调用树的 const begin 方法，返回 const iterator 了。
map 的迭代器
我们的预期是 map 的非 const 迭代器不可以修改 key，但可以修改 value，而 const 迭代器既不能修改 key，也不能修改 value，如何做到？
在 map 中是这样声明树型结构的：
RBTree<K, pair<const K, V>, MapKeyOfT> _t;树结点存储的是 pair<const K, V>，key 值被 const 修饰，
迭代器是这样声明的：
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator; typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;与 set 不同，在 map 中 iterator 是树的 iterator 迭代器，而 const iterator 是树的 const iterator 迭代器，而树的 const iterator 和 iterator 的 operator* 的返回值分别是 const T& 和 T&，在map中也就是 const pair<const K, V> 和 pair<const K, V>，这样就解决了问题
4.3 insert 的实现
我们知道，map 和 set 的 insert 会返回一个 pair：
pair<iterator,bool> insert (const value_type& val);
iterator：如果插入成功，iterator 指向新插入的结点，如果失败，指向已经存在 set 的结点
bool ：如果插入成功，返回 true，如果失败返回 false
如何做到呢？
红黑树的 insert 函数的声明：
pair<iterator, bool> Insert(const T& data)如果在 set 的 insert 函数直接返回红黑树的 insert 的结果，由于红黑树的 insert 的结果 pair 中 iterator 是非 const，而在 set 中不管是 iterator 还是 const iterator 都是树的 const iterator 迭代器，编译器会认为函数的返回值和声明的函数返回值类型完全不同而报错（有人认为这不是权限的缩小吗，为什么会报错？原因是同一个类模板接收不同模板参数实例化的类型是完全不同的类型，比如 vector<int> 和 vector<char> 是完全不同的类型，它们的指针就谈不上权限，只有相同类型才有权限，比如 int* 和 const int*）
解决办法就是先用一个 pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> 类型的临时变量接收红黑树的 insert 的结果，再用这个临时变量构造一个 pair<typename RBTree<K, K, SetKeyOfT>::const_iterator, bool>类型的变量，也就是用一个非 const 的迭代器构造一个 const 迭代器。
// set 的 insert
pair<iterator, bool> insert(const K& key)
{
// 1. 获取红黑树的插入结果
pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
// 2. 手动构造pair，在构造过程中进行迭代器类型转换
return pair<iterator, bool>(ret.first, ret.second);
}而在 map 中，iterator 就是树的 iterator 迭代器，const iterator 就是树的 const iterator 迭代器，可以直接返回红黑树的 insert 的结果
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _t.Insert(kv);
}那么如何用一个非 const 的迭代器构造一个 const 迭代器呢？在树的迭代器的定义中：
template<class T, class Ptr, class Ref>
struct __TreeIterator
{
typedef RBTreeNode<T> Node;
typedef __TreeIterator<T, Ptr, Ref> Self;
typedef __TreeIterator<T, T*, T&> Iterator;
__TreeIterator(const Iterator& it)
:_node(it._node)
{}
...在树的迭代器中，有 typedef __TreeIterator<T, T*, T&> Iterator;，它不受 Ptr 和 Ref 实例化后的影响，它总是普通迭代器，它保证不管迭代器被实例化为一个 const 迭代器还是普通迭代器，总能用一个普通迭代器去构造它。
模拟实现
RBTree.h
#pragma once
#include <utility>
#include <iostream>
using namespace std;
// 枚举值表示颜色
enum Colour
{
RED,
BLACK
};
// 这里我们默认按key/value结构实现
template<class T>
struct RBTreeNode
{
// 这里更新控制平衡也要加入parent指针
T _data;
RBTreeNode<T>* _left;
RBTreeNode<T>* _right;
RBTreeNode<T>* _parent;
Colour _col;
RBTreeNode(const T& data, Colour col = RED)
:_data(data)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _col(col)
{}
};
template<class T,class Ref,class Ptr>
struct RBTreeIterator
{
typedef RBTreeNode<T> Node;
typedef RBTreeIterator<T,Ref,Ptr> Self;
typedef RBTreeIterator<T, T&, T*> iterator;
Node* _node;
RBTreeIterator(Node* node)
:_node(node)
{}
RBTreeIterator(const iterator& it)
:_node(it._node)
{}
Self& operator++()
{
if (_node->_right)
{
Node* cur = _node->_right;
while (cur->_left)
{
cur = cur->_left;
}
_node = cur;
}
else
{
Node* parent = _node->_parent;
while (parent && parent->_right == _node)
{
_node = _node->_parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator!=(const Self& s)const
{
return _node != s._node;
}
bool operator==(const Self& s)const
{
return _node == s._node;
}
};
template<class K, class T, class KeyOfT>
class RBTree
{
typedef RBTreeNode<T> Node;
KeyOfT kot;
public:
typedef RBTreeIterator<T,T&,T*> iterator;
typedef RBTreeIterator<T,const T&, const T*> const_iterator;
pair<iterator,bool> Insert(const T& data)
{
Node* tmp;
if (_root == nullptr)
{
_root = new Node(data, BLACK);
return {iterator(_root),true};
}
else
{
Node* cur = _root;
Node* parent = nullptr;
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 { iterator(cur),false };
}
cur = new Node(data);
tmp = cur;
if (kot(parent->_data) > kot(data)) parent->_left = cur;
else parent->_right = cur;
cur->_parent = parent;
while (parent->_col == RED)
{
Node* g = parent->_parent;
Node* uncle = nullptr;
if (parent == g->_left) uncle = g->_right;
else uncle = g->_left;
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
g->_col = RED;
if (g == _root)
{
g->_col = BLACK;
return { iterator(tmp),true };
}
if (g->_parent && g->_parent->_col == BLACK) return { iterator(tmp),true };
cur = g;
parent = cur->_parent;
}
else
{
if (parent == g->_left)
{
if (cur == parent->_left)
{
rotateR(g);
parent->_col = BLACK;
g->_col = RED;
if (g == _root) g->_col = BLACK;
return { iterator(tmp),true };
}
else if (cur == parent->_right)
{
rotateL(parent);
swap(parent, cur);
}
}
else if (parent == g->_right)
{
if (cur == parent->_right)
{
rotateL(g);
parent->_col = BLACK;
g->_col = RED;
if (g == _root) g->_col = BLACK;
return { iterator(tmp),true };
}
else if (cur == parent->_left)
{
rotateR(parent);
swap(parent, cur);
}
}
}
}
}
return { iterator(tmp),true };
}
iterator begin()
{
Node* cur = _root;
while (cur->_left) cur = cur->_left;
return iterator(cur);
}
iterator end()
{
return iterator(nullptr);
}
const_iterator begin() const
{
Node* cur = _root;
while (cur->_left) cur = cur->_left;
return const_iterator(cur);
}
const_iterator end() const
{
return iterator(nullptr);
}
void rotateR(Node* parent)
{
Node* psubL = parent->_left;
Node* psubLR = psubL->_right;
parent->_left = psubLR;
if (psubLR) psubLR->_parent = parent;
Node* pparent = parent->_parent;
psubL->_right = parent;
parent->_parent = psubL;
psubL->_parent = pparent;
if (pparent == nullptr)
{
_root = psubL;
}
else
{
if (pparent->_left == parent)
{
pparent->_left = psubL;
}
else if (pparent->_right == parent)
{
pparent->_right = psubL;
}
}
}
void rotateL(Node* parent)
{
Node* psubR = parent->_right;
Node* psubRL = psubR->_left;
parent->_right = psubRL;
if (psubRL) psubRL->_parent = parent;
psubR->_left = parent;
Node* pparent = parent->_parent;
parent->_parent = psubR;
psubR->_parent = pparent;
if (pparent == nullptr)
{
_root = psubR;
}
else
{
if (parent == pparent->_left)
{
pparent->_left = psubR;
}
else if (parent == pparent->_right)
{
pparent->_right = psubR;
}
}
}
void InOrder()
{
_InOrder(_root);
}
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << " ";
_InOrder(root->_right);
}
bool is_RBTree()
{
return _is_RBTree(_root);
}
bool _is_RBTree(Node* root)
{
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;
}
return check_col(root, 0, benchmark);
}
bool check_col(Node* root, int num, int benchmark)
{
if (root == nullptr)
{
if (num != benchmark) return false;
return true;
}
if (root->_col == RED && root->_parent && root->_parent->_col == RED) return false;
if (root->_col == BLACK) ++num;
return check_col(root->_left, num, benchmark) && check_col(root->_right, num, benchmark);
}
private:
Node* _root = nullptr;
};Myset.h
#pragma once
#include "RBTree.h"
template<class T>
class set
{
struct KeyOfKey
{
const T& operator()(const T& data)
{
return data;
}
};
public:
typedef typename RBTree<T, T, KeyOfKey>::const_iterator iterator;
typedef typename RBTree<T, T, KeyOfKey>::const_iterator const_iterator;
const_iterator begin() const
{
return _t.begin();
}
const_iterator end() const
{
return _t.end();
}
pair<iterator, bool> insert(const T data)
{
pair<typename RBTree<T, T, KeyOfKey>::iterator, bool> ret = _t.Insert(data);
return pair<iterator, bool>(ret.first, ret.second);
//return _t.Insert(data);
}
private:
RBTree<T, T, KeyOfKey> _t;
};Mymap.h
#pragma once
#include "RBTree.h"
template<class K,class V>
class map
{
struct KeyOfKey
{
const K& operator()(const pair<K, V>& data)
{
return data.first;
}
};
public:
typedef typename RBTree<K, pair<const K, V>, KeyOfKey>::iterator iterator;
typedef typename RBTree<K, pair<const K, V>, KeyOfKey>::const_iterator const_iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
const_iterator cbegin() const
{
return _t.begin();
}
const_iterator cend() const
{
return _t.end();
}
pair<const_iterator, bool> insert(const pair<K, V>& data)
{
return _t.Insert(data);
}
V& operator[](const K& data)
{
pair<iterator, bool> ret = _t.Insert({data,V()});
return ret.first->second;
}
private:
RBTree<K, pair<const K, V>, KeyOfKey> _t;
};
扫一扫
2030
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
