C++ 用红黑树封装map/set
前言
之前的文章讲解了红黑树的具体实现，本篇文章就用红黑树来封装一个map/set出来，但是大家在实现前一定要保证红黑树不要出现问题，如果红黑树有问题还是要先把红黑树调好再来实现封装。
一、源码结构分析
以下源码来自SGI-STL3.0版本，map和set的源代码在map/set/stl_map.h/stl_set.h/stl_tree.h等⼏个头文件中，下面是截取的一部分核心代码
// stl_set.h
template <class Key, class Compare = less<Key>, class Alloc = alloc>
class set {
public:
typedef Key key_type;
typedef Key value_type;
private:
typedef rb_tree<key_type, value_type,
identity<value_type>, key_compare, Alloc> rep_type;
rep_type t;
};
// stl_map.h
template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
class map {
public:
typedef Key key_type;
typedef T mapped_type;
typedef pair<const Key, T> value_type;
private:
typedef rb_tree<key_type, value_type,
select1st<value_type>, key_compare, Alloc> rep_type;
rep_type t;
};
// stl_tree.h
struct __rb_tree_node_base
{
typedef __rb_tree_color_type color_type;
typedef __rb_tree_node_base* base_ptr;
color_type color;
base_ptr parent;
base_ptr left;
base_ptr right;
};
// stl_tree.h
template <class Key, class Value, class KeyOfValue, class Compare, class Alloc = alloc>
class rb_tree {
protected:
typedef void* void_pointer;
typedef __rb_tree_node_base* base_ptr;
typedef __rb_tree_node<Value> rb_tree_node;
typedef simple_alloc<rb_tree_node, Alloc> rb_tree_node_allocator;
typedef __rb_tree_color_type color_type;
public:
typedef Key key_type;
typedef Value value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef rb_tree_node* link_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
protected:
size_type node_count; // keeps track of size of tree
link_type header;
Compare key_compare;
};
// stl_tree.h
template <class Value>
struct __rb_tree_node : public __rb_tree_node_base
{
typedef __rb_tree_node<Value>* link_type;
Value value_field;
};
通过上图的分析，可以看到源码中rb_tree用了一个泛型的思想来实现，rb_tree是实现key的搜索场景，还是key/value的搜索场景不是直接写死的，而是第二个模板参数Value决定_rb_tree_node中存储的数据类型。
set实例化rb_tree时第二个模板参数给的是key，map实例化rb_tree时第二个模板参数给的是
pair<const key, T>，这样一颗红黑树既可以实现key搜索场景的set，也可以实现key/value搜索场
景的map。
也就是说对于set来说，Key是Key，Value也是Key，对于map来说，Key是Key，Value是pair，而rb_tree的第二个模版参数Value才是真正存在节点里面的，所以set在节点中存的就是一个Key，map在节点中存的是pair。
那既然rb_tree第二个模板参数Value已经控制了红黑树结点中存储的数据类型，为什么还要传第一个模板参数Key呢？其实是因为在find/erase时的函数参数都是Key，所以第⼀个模板参数是传给find/erase等函数做形参的类型的。
那我们自己的map/set以及红黑树的修改就如下：
namespace hx
{
template<class K>
class set
{
public:
private:
RBTree<K, K> _t;
};
}namespace hx
{
template<class K, class V>
class map
{
public:
private:
RBTree<K, pair<K, V>> _t;
};
}enum Color
{
RED,
BLACK
};
template<class T>
struct RBTreeNode
{
T _data;
RBTreeNode* _left;
RBTreeNode* _right;
RBTreeNode* _parent;
Color _col;
RBTreeNode(const T& data)
:_data(data)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
{}
};
template<class K, class T, class KeyOfT>
struct RBTree
{
typedef RBTreeNode<T> Node;
public:
private:
Node* _root = nullptr;
};二、模拟实现map/set
模拟实现一共分为五步：
1、套上KeyOfT
2、普通迭代器
3、const迭代器
4、解决Key不能修改的问题
5、map的[]实现
2.1 套上KeyOfT
既然已经知道了红黑树的第二个模版参数才是存在节点里的，那先对红黑树以及节点类进行一个修改
template<class T>
struct RBTreeNode
{
T _data;
RBTreeNode* _left;
RBTreeNode* _right;
RBTreeNode* _parent;
Color _col;
RBTreeNode(const T& data)
:_data(data)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
{}
};
template<class K, class T>
struct RBTree
{
typedef RBTreeNode<T> Node;
public:
bool insert(const T& data)
{
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
// 问题出现了
if (cur->_data < data)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_data > data)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}将节点类修改成一个模版参数T，insert的参数也是插入一个key，但是在cur中的_data与形参data比较的时候问题就来了，如果data是key，那么直接比较没问题，但是如果是一个pair呢？库中虽然重载了pair的比较大小，但是库中的比较方式是，first大就大，如果first相等，那second大就大，如果first和second都相等，这两个pair对象才相同。这显然不符合我们的需求，我们要的是如果first相等，那两个pair对象就是相等，那就需要上一个仿函数来自己控制这里的比较逻辑。
但是又没有办法在红黑树中写仿函数，因为对于下层来说，根本就不知道节点中存储的数据类型是什么，那下层不知道，但是上层知道，所以就可以在map和set中定义仿函数，作为模版参数传进来，通过仿函数去取出对象里面的key。
namespace hx
{
template<class K>
class set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
private:
RBTree<K, K, SetKeyOfT> _t;
};
}namespace hx
{
template<class K, class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
private:
RBTree<K, pair<K, V>, MapKeyOfT> _t;
};
}template<class K, class T, class KeyOfT>
struct RBTree
{
typedef RBTreeNode<T> Node;
public:
bool insert(const T& data)
{
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return true;
}
// 定义对象
KeyOfT kot;
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
// 去取里面的key
if (kot(cur->_data) < kot(data))
{
parent = cur;
cur = cur->_right;
}
// 去取里面的key
else if (kot(cur->_data) > kot(data))
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(data);
Node* newnode = cur;
if (kot(parent->_data) < kot(data))
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
// ...
// 还有很多代码，但是在这里只留下需要修改的部分
}
};这样就完美的解决了问题，用一个模版参数，data中存的是Key，就去把这个Key取出来，存的是pair，就去把这个pair中的Key取出来。map和set的insert直接就去调用树的insert。
// set
namespace hx
{
template<class K>
class set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
bool insert(const K& key)
{
return _t.insert(key);
}
private:
RBTree<K, K, SetKeyOfT> _t;
};
}
// map
namespace hx
{
template<class K, class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
bool insert(const pair<K, V>& kv)
{
return _t.insert(kv);
}
private:
RBTree<K, pair<K, V>, MapKeyOfT> _t;
};
}2.2 普通迭代器实现
iterator实现的大体框架跟list的iterator思路是一致的，用一个类型封装结点的指针，再通过重载运算符实现，迭代器像指针一样访问的行为。
这里的难点是operator++和operator--的实现。map和set的迭代器走的是中序遍历，左子树->根结点->右子树，那么begin()会返回中序第一个结点的迭代器，也就是最左节点。
迭代器++的核心逻辑就是不看全局，只看局部，只考虑当前中序局部要访问的下一个结点。
迭代器++时，如果it指向的结点的右子树不为空，代表当前结点已经访问完了，因为是左根右，左子树和根已经访问完了，要去访问右子树了，要访问下一个结点是右子树的中序第一个，一棵树中序第一个是最左结点，所以直接找右子树的最左结点即可。
迭代器++时，如果it指向的结点的右子树为空，代表当前结点已经访问完了，且当前结点所在的子树也访问完了，要访问的下一个结点在当前结点的祖先里面，所以要沿着当前结点到根的祖先路径向上找。例如：25的右子树为空，以25做根的这棵局部子树就访问完了，要看当前节点25在父亲的哪里，父亲是30，25是30的左，那就说明下一个要访问的节点就是父亲所在的节点30。
如果当前结点是父亲的右，根据中序左子树->根结点->右子树，当前结点所在的子树访问完 了，当前结点所在父亲的子树也访问完了，那么下一个访问的需要继续往根的祖先中去找，直到找 到孩子是父亲左的那个祖先就是中序要问题的下一个结点。例如：it指向15，15右为空，父亲是10，15是10的右，15所在的子树访问完了，10所在的子树也访问完了，继续往上找，父亲是20，10是20的左，那么下一个访问的结点就是18。
如果it在50，50的右为空，50为根的这棵子树访问完了，父亲是40，50是40的右，说明40所在的子树访问完了。继续向上从祖先中找，当前节点是40，父亲是30，40是30的右，说明30所在的子树访问完了。当前节点是30，父亲是20，30是20的右，说明20所在的子树访问完了。当前节点是20，父亲是空。结束遍历。
总结：当右子树不为空时，下一个要访问的节点就是右子树的最左节点，当右子树为空时，看当前节点在父亲的左还是右，如果在父亲的左，下一个要访问的节点就是父亲，如果在父亲的右，那就要到当前节点的祖先中去查找，直到找 到孩子是父亲左的那个祖先就是要访问的下一个结点，如果父亲为空了，那整棵树就遍历完了，也让当前节点去指向父亲。end()的结束我们定义成走到空就是结束。
template<class T>
struct __RBTree_Iterator
{
typedef __RBTree_Iterator<T> Self;
typedef RBTreeNode<T> Node;
Node* _node;
__RBTree_Iterator(Node* node)
:_node(node)
{}
Self& operator++()
{
// 右子树不为空
if (_node->_right)
{
_node = _node->_right;
// 找右子树的最左节点
while (_node->_left)
{
_node = _node->_left;
}
}
else
{
// 右子树为空
Node* cur = _node;
Node* parent = cur->_parent;
// 循环的找，当找到孩子是父亲的左时，父亲就是下一个要访问的节点
while (parent && parent->_right == cur)
{
cur = parent;
parent = parent->_parent;
}
// 无论是因为孩子是父亲的左，还是因为父亲为空了，下一个要访问的节点都是parent
_node = parent;
}
return *this;
}
};迭代器--也是一样的道理，只不过就是反过来，按照右子树->根->左子树的顺序遍历。当左子树不为空时，下一个要访问的节点就是左子树的最右节点，当左子树为空时，看当前节点在父亲的左还是右，如果在父亲的右，下一个要访问的节点就是父亲，如果在父亲的左，那就要到当前节点的祖先中去查找，直到找到孩子是父亲右的那个祖先就是要访问的下一个结点，如果父亲为空了，那整棵树就遍历完了，也让当前节点去指向父亲。
Self& operator--()
{
if (_node->_left)
{
_node = _node->_left;
while (_node->_right)
{
_node = _node->_right;
}
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && parent->_left == cur)
{
cur = parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}那++和--实现完了，其他的就和list的迭代器是一样的了，我们把其余功能补全
template<class T>
struct __RBTree_Iterator
{
typedef __RBTree_Iterator<T> Self;
typedef RBTreeNode<T> Node;
Node* _node;
__RBTree_Iterator(Node* node)
:_node(node)
{}
T& operator*()
{
return _node->_data;
}
T* operator->()
{
return &_node->_data;
}
Self& operator++()
{
// 右子树不为空
if (_node->_right)
{
_node = _node->_right;
// 找右子树的最左节点
while (_node->_left)
{
_node = _node->_left;
}
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
// 循环的找，当找到孩子是父亲的左时，父亲就是下一个要访问的节点
while (parent && parent->_right == cur)
{
cur = parent;
parent = parent->_parent;
}
// 无论是因为孩子是父亲的左，还是因为父亲为空了，下一个要访问的节点都是parent
_node = parent;
}
return *this;
}
Self operator++(int)
{
Self tmp = *this;
++*this;
return tmp;
}
Self& operator--()
{
if (_node->_left)
{
_node = _node->_left;
while (_node->_right)
{
_node = _node->_right;
}
}
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 tmp = *this;
--*this;
return tmp;
}
bool operator!=(const Self& s)
{
return _node != s._node;
}
bool operator==(const Self& s)
{
return _node == s._node;
}
};
template<class K, class T, class KeyOfT>
struct RBTree
{
typedef RBTreeNode<T> Node;
public:
typedef __RBTree_Iterator<T> iterator;
iterator begin()
{
Node* minleft = _root;
while (minleft && minleft->_left)
{
minleft = minleft->_left;
}
return minleft;
}
iterator end()
{
return nullptr;
}
};
下层实现好了要继续来实现上层
namespace hx
{
template<class K>
class set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
// 要加上typename
typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
bool insert(const K& key)
{
return _t.insert(key);
}
private:
RBTree<K, K, SetKeyOfT> _t;
};
}这里一定要注意，在取红黑树里面的迭代器时，属于类模版中取内嵌类型，一定要加上typename，因为编译器不知道这里的iterator是类型还是对象，加上typename就是告诉编译器是类型，等模版实例化了再去找。map也是同理。
namespace hx
{
template<class K, class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
// 一定要加typename
typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
bool insert(const pair<K, V>& kv)
{
return _t.insert(kv);
}
private:
RBTree<K, pair<K, V>, MapKeyOfT> _t;
};
}2.3 const迭代器实现
我们知道普通迭代器和const迭代器的不同就是在operator*和operator->的返回值，和list一样，其他不变就好了
template<class T, class Ref, class Ptr>
struct __RBTree_Iterator
{
typedef __RBTree_Iterator<T, Ref, Ptr> Self;
typedef RBTreeNode<T> Node;
Node* _node;
__RBTree_Iterator(Node* node)
:_node(node)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
Self& operator++()
{
// 右子树不为空
if (_node->_right)
{
_node = _node->_right;
// 找右子树的最左节点
while (_node->_left)
{
_node = _node->_left;
}
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
// 循环的找，当找到孩子是父亲的左时，父亲就是下一个要访问的节点
while (parent && parent->_right == cur)
{
cur = parent;
parent = parent->_parent;
}
// 无论是因为孩子是父亲的左，还是因为父亲为空了，下一个要访问的节点都是parent
_node = parent;
}
return *this;
}
Self operator++(int)
{
Self tmp = *this;
++*this;
return tmp;
}
Self& operator--()
{
if (_node->_left)
{
_node = _node->_left;
while (_node->_right)
{
_node = _node->_right;
}
}
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 tmp = *this;
--*this;
return tmp;
}
bool operator!=(const Self& s)
{
return _node != s._node;
}
bool operator==(const Self& s)
{
return _node == s._node;
}
};
template<class K, class T, class KeyOfT>
struct RBTree
{
typedef RBTreeNode<T> Node;
public:
typedef __RBTree_Iterator<T, T&, T*> iterator;
typedef __RBTree_Iterator<T, const T&, const T*> const_iterator;
iterator begin()
{
Node* minleft = _root;
while (minleft && minleft->_left)
{
minleft = minleft->_left;
}
return minleft;
}
iterator end()
{
return nullptr;
}
const_iterator begin() const
{
Node* minleft = _root;
while (minleft && minleft->_left)
{
minleft = minleft->_left;
}
return minleft;
}
const_iterator end() const
{
return nullptr;
}
};namespace hx
{
template<class K>
class set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;
typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
const_iterator begin() const
{
return _t.begin();
}
const_iterator end() const
{
return _t.end();
}
pair<iterator, bool> insert(const K& key)
{
return _t.insert(key);
}
private:
RBTree<K, K, SetKeyOfT> _t;
};
}namespace hx
{
template<class K, class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;
typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::const_iterator const_iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
const_iterator begin() const
{
return _t.begin();
}
const_iterator end() const
{
return _t.end();
}
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _t.insert(kv);
}
private:
RBTree<K, pair<K, V>, MapKeyOfT> _t;
};
}2.4 解决key不能修改的问题
在map和set中，key是不能修改的，map的value可以修改，在key前加上const修饰即可
namespace hx
{
template<class K>
class set
{
public:
typedef typename RBTree<K, const K, SetKeyOfT>::iterator iterator;
typedef typename RBTree<K, const K, SetKeyOfT>::const_iterator const_iterator;
private:
RBTree<K, const K, SetKeyOfT> _t;
};
}namespace hx
{
template<class K, class V>
class map
{
public:
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;
private:
RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};
}注意map中，const可不要加在pair前面了，加在pair前面那就是first和second都不能修改，但我们要的只是first不能修改。
2.5 map的[]实现
[]中要调用insert，所以要先把insert的返回值修改成pair<iterator, bool>类型
pair<iterator, bool> insert(const T& data)
{
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return { _root, true };
}
// 定义对象
KeyOfT kot;
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
// 去取里面的key
if (kot(cur->_data) < kot(data))
{
parent = cur;
cur = cur->_right;
}
// 去取里面的key
else if (kot(cur->_data) > kot(data))
{
parent = cur;
cur = cur->_left;
}
else
{
return { cur, false };
}
}
cur = new Node(data);
// 重新定义出来一个节点newnode
Node* newnode = cur;
if (kot(parent->_data) < kot(data))
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
cur->_col = RED;
// ... 调平衡
_root->_col = BLACK;
return { newnode, true };
}如果根为空就，就返回{_root, true}，代表插入成功，如果值已经存在，就返回已经存在的节点{cur, false}，如果根不为空，也没有这个值，返回的节点指针一定不要用cur，因为在调整平衡的时候cur可能已经不知道走到哪去了，提前记录一个newnode，用{newnode, true}返回。
// set
pair<iterator, bool> insert(const K& key)
{
return _t.insert(key);
}// map
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _t.insert(kv);
}
V& operator[](const K& key)
{
pair<iterator, bool> ret = _t.insert({ key, V() });
return ret.first->second;
}[]的实现是先去调用insert，插入一个value的匿名对象就可以，会去调用value的默认构造，并且接收返回值，ret.first拿到的就是迭代器对象，里面存储的就是节点的指针，不管这个key是之前就存在，还是新插入进去的，都是这个节点的指针，迭代器对象去调用operator->拿到pair的地址，再解引用拿second，为了可读性两个->省略成了一个。
2.6 map/set以及红黑树源码
2.6.1 RBTree.h
{
RED,
BLACK
};
template<class T>
struct RBTreeNode
{
T _data;
RBTreeNode* _left;
RBTreeNode* _right;
RBTreeNode* _parent;
Color _col;
RBTreeNode(const T& data)
:_data(data)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
{}
};
template<class T, class Ref, class Ptr>
struct __RBTree_Iterator
{
typedef __RBTree_Iterator<T, Ref, Ptr> Self;
typedef RBTreeNode<T> Node;
Node* _node;
__RBTree_Iterator(Node* node)
:_node(node)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
Self& operator++()
{
// 右子树不为空
if (_node->_right)
{
_node = _node->_right;
// 找右子树的最左节点
while (_node->_left)
{
_node = _node->_left;
}
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
// 循环的找，当找到孩子是父亲的左时，父亲就是下一个要访问的节点
while (parent && parent->_right == cur)
{
cur = parent;
parent = parent->_parent;
}
// 无论是因为孩子是父亲的左，还是因为父亲为空了，下一个要访问的节点都是parent
_node = parent;
}
return *this;
}
Self operator++(int)
{
Self tmp = *this;
++*this;
return tmp;
}
Self& operator--()
{
if (_node->_left)
{
_node = _node->_left;
while (_node->_right)
{
_node = _node->_right;
}
}
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 tmp = *this;
--*this;
return tmp;
}
bool operator!=(const Self& s)
{
return _node != s._node;
}
bool operator==(const Self& s)
{
return _node == s._node;
}
};
template<class K, class T, class KeyOfT>
struct RBTree
{
typedef RBTreeNode<T> Node;
public:
typedef __RBTree_Iterator<T, T&, T*> iterator;
typedef __RBTree_Iterator<T, const T&, const T*> const_iterator;
iterator begin()
{
Node* minleft = _root;
while (minleft && minleft->_left)
{
minleft = minleft->_left;
}
return minleft;
}
iterator end()
{
return nullptr;
}
const_iterator begin() const
{
Node* minleft = _root;
while (minleft && minleft->_left)
{
minleft = minleft->_left;
}
return minleft;
}
const_iterator end() const
{
return nullptr;
}
pair<iterator, bool> insert(const T& data)
{
if (_root == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return { _root, true };
}
// 定义对象
KeyOfT kot;
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
// 去取里面的key
if (kot(cur->_data) < kot(data))
{
parent = cur;
cur = cur->_right;
}
// 去取里面的key
else if (kot(cur->_data) > kot(data))
{
parent = cur;
cur = cur->_left;
}
else
{
return { cur, false };
}
}
cur = new Node(data);
Node* newnode = cur;
if (kot(parent->_data) < kot(data))
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
cur->_col = RED;
while (parent && parent->_col == RED)
{
Node* grandfather = parent->_parent;
if (grandfather->_left == parent)
{
Node* uncle = grandfather->_right;
// 调整
if (uncle && uncle->_col == RED) // 叔叔存在且为红
{
// 变色
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
// 继续向上调整
cur = grandfather;
parent = cur->_parent;
}
else // 叔叔不存在或叔叔存在且为黑
{
if (parent->_left == cur)
{
RotateR(grandfather);
grandfather->_col = RED;
parent->_col = BLACK;
}
else
{
RotateL(parent);
RotateR(grandfather);
grandfather->_col = RED;
cur->_col = BLACK;
}
break; // 旋转完子树平衡，不需要继续调整
}
}
else //grandfather->_right == parent
{
Node* uncle = grandfather->_left;
if (uncle && uncle->_col == RED) // 叔叔存在且为红
{
parent->_col = uncle->_col = BLACK; // 变色
grandfather->_col = RED;
// 继续向上调整
grandfather = cur;
parent = cur->_parent;
}
else // 叔叔不存在或叔叔存在且为黑
{
if (parent->_right == cur)
{
RotateL(grandfather);
grandfather->_col = RED;
parent->_col = BLACK;
}
else
{
RotateR(parent);
RotateL(grandfather);
grandfather->_col = RED;
cur->_col = BLACK;
}
break; // 旋转完子树平衡，不需要继续调整
}
}
}
_root->_col = BLACK;
return { newnode, true };
}
void RotateR(Node* parent)
{
Node* cur = parent->_left;
Node* curright = cur->_right;
parent->_left = curright;
if (curright)
curright->_parent = parent;
cur->_right = parent;
Node* parentParent = parent->_parent;
parent->_parent = cur;
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else
{
if (parentParent->_left == parent)
{
parentParent->_left = cur;
}
else
{
parentParent->_right = cur;
}
cur->_parent = parentParent;
}
}
void RotateL(Node* parent)
{
Node* cur = parent->_right;
Node* curleft = cur->_left;
parent->_right = curleft;
if (curleft)
curleft->_parent = parent;
cur->_left = parent;
Node* parentParent = parent->_parent;
parent->_parent = cur;
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else
{
if (parentParent->_left == parent)
{
parentParent->_left = cur;
}
else
{
parentParent->_right = cur;
}
cur->_parent = parentParent;
}
}
bool find(const K& key)
{
KeyOfT kot;
Node* cur = _root;
while (cur)
{
if (kot(cur->_data) < key)
{
cur = cur->_right;
}
else if (kot(cur->_data) > key)
{
cur = cur->_left;
}
else
{
return true;
}
}
return false;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->_left);
cout << root->_kv.first << " ";
_InOrder(root->_right);
}
int Height()
{
return _Height(_root);
}
int _Height(Node* root)
{
if (root == nullptr)
return 0;
int retleft = _Height(root->_left);
int retright = _Height(root->_right);
return retleft > retright ? retleft + 1 : retright + 1;
}
int size()
{
return _size(_root);
}
int _size(Node* root)
{
if (root == nullptr)
return 0;
return _size(root->_left) + _size(root->_right) + 1;
}
bool Check(Node* root, int refersum, int cursum)
{
if (root == nullptr)
{
// 走到空与基准值refersum作比较，检查规则四
if (refersum != cursum)
{
cout << "每条路径上黑色节点的数量不相等" << endl;
return false;
}
return true;
}
// 检查规则三
if (root->_col == RED && root->_parent && root->_parent->_col == RED)
{
cout << "出现连续的红色节点" << endl;
return false;
}
// 遇到黑色节点就++
if (root->_col == BLACK)
cursum++;
// 继续递归去检查
return Check(root->_left, refersum, cursum)
&& Check(root->_right, refersum, cursum);
}
bool isBalance()
{
// 空树也是红黑树
if (_root == nullptr)
return true;
// 检查规则二
if (_root->_col == RED)
return false;
// 用最左边的路径作为参考值
int BlackSum = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
BlackSum++;
cur = cur->_left;
}
return Check(_root, BlackSum, 0);
}
private:
Node* _root = nullptr;
};2.6.2 set.h
namespace hx
{
template<class K>
class set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
public:
typedef typename RBTree<K, const K, SetKeyOfT>::iterator iterator;
typedef typename RBTree<K, const K, SetKeyOfT>::const_iterator const_iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
const_iterator begin() const
{
return _t.begin();
}
const_iterator end() const
{
return _t.end();
}
pair<iterator, bool> insert(const K& key)
{
return _t.insert(key);
}
private:
RBTree<K, const K, SetKeyOfT> _t;
};
}2.6.3 map.h
namespace hx
{
template<class K, class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
const_iterator begin() const
{
return _t.begin();
}
const_iterator end() const
{
return _t.end();
}
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _t.insert(kv);
}
V& operator[](const K& key)
{
pair<iterator, bool> ret = _t.insert({ key, V() });
return ret.first->second;
}
private:
RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};
}总结
本篇文章讲的非常细致，一步一步去实现，没有跨越什么，大家在实现的时候也一定要一步一步的来，写完这一步，测试没有问题了，再去搞下一步，不要想着一口吃个胖子，可千万不要出现最后功能都实现好了，结果红黑树的实现有问题这种情况。对于map和set我们实现这些功能就可以了，那如果大家觉得小编写的还不错，可以给小编一个三连表示支持！！！感谢大家！
原文地址：https://blog.csdn.net/2401_84771520/article/details/147223165
免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！