用同一个树的类模板封装map(key/value)和set(key)
红黑树的Node
template
struct RBTreeNode
{
RBTreeNode* _left;
RBTreeNode* _right;
RBTreeNode* _parent;
T _data;
Colour _col;
RBTreeNode(const T& data)
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_data(data)
,_col(BLACK)
{}
};
用只有一个data变量来代替map的pair
template
struct RBTree
看红黑树的模板的我们依然保留key模板,对于Set来说key和T都是value的,对于map来说key 是 key,T是pair
RBTree,MapKeyOfT> _t;
RBTree _t;
由此相当于适配器模式,对于set来说第二个模板参数不是必要的。
由此我们可以思考,我们对两个对象的封装可以先统一起来某种形式,比如都提供两个模板参数。
红黑树的insert返回值由原来的bool变成了pair
pair Insert(const T& data)
//......
return make_pair(iterator(newnode), true);
//
注意实际上map和set的迭代器属性不一样,但我们返回权限大的普通迭代器,后面再分别进行const限制来适配
typedef __TreeIterator iterator;
写红黑树的迭代器
template
struct __TreeIterator
{
typedef RBTreeNode Node;
typedef __TreeIterator< T, Ptr, Ref> Self;
// Iterator只可能是普通迭代器
typedef __TreeIterator< T, T*, T&> Iterator;
Node* _node;
__TreeIterator(const Iterator& It)
:_node(It._node)
{}
__TreeIterator(Node* node)
:_node(node)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
Self& operator++()
{
//右边不为空
if (_node->right)
{
Node* leftmin = _node->_right;
while (leftmin->_left)
{
leftmin = leftmin->_left;
}
_node = leftmin;
return *this;
}
else
{// 右树为空
Node* parent = _node->_parent;
while (parent&&_node == parent->right)
{
_node = parent;
parent = _node->_parent;
}
_node = parent;
return *this;
}
}
bool operator!=(const Iterator it)const
{
return _node != it._node;
}
bool operator==(const Iterator)const
{
return _node == it._node;
}
Self& operator--()
{
//左不为空
if (_node->_left)
{
Node* rightmax = _node->_left;
while (rightmax->_right)
{
rightmax = rightmax->_right;
}
_node = rightmax;
return *this;
}
else
{
Node* parent = _node->_parent;
while (parent && parent->_right == _node)
{
_node = parent;
parent = _node->_parent;
}
_node = parent;
return *this;
}
}
};
比较重要的点是拷贝构造函数
__TreeIterator(const Iterator& It)
:_node(It._node)
{}
对于普通迭代器,是拷贝构造,同时它也可以接收普通迭代器来构造const 修饰的迭代器。
operate()++的分析
当右树存在时,再右子树的最大值,当右树不存在,找到parent节点向上处理,当cur是parentd1左节点时,parent就是下一个节点。
红黑树的begin(),end()方法
typedef __TreeIterator iterator;
typedef __TreeIterator const_iterator;
iterator begin()
{
Node* leftMin = _root;
while (leftMin && leftMin->_left)
{
leftMin=leftMin->_left;
}
return iterator(leftMin);
}
iterator end()
{
return iterator(nullptr);
}
const_iterator begin()const
{
Node* leftMin = _root;
while (leftMin && leftMin->_left)
{
leftMin = leftMin->_left;
}
return const_iterator(leftMin);
}
const_iterator end()const
{
return const_iterator(nullptr);
}
这里用了没有直接返回Node*指针而是返回迭代器对象,调用拷贝构造函数。
map和set的迭代器有不同的需求,对于set而言,iterator就是const_iterator。
typedef typename RBTree::const_iterator iterator;
typedef typename RBTree::const_iterator const_iterator;
set的begin()
iterator begin()
{
return _t.begin();
}
当begin()调用时 _t.begin()返回的是iterator这是就是可以通过__TreeIterator的拷贝构造实现转换成Iterator,(其实可以直接调用const的begin()修饰的函数)
insert封装
pair insert(const K& key)
{
pair::iterator, bool>ret = _t.Insert(key);
return pair(ret.first, ret.second);
}
注意此时的问题,insert规定返回值必须是pair
而map的迭代器要确保pair
typedef typename RBTree, MapKeyOfT>::iterator iterator;
typedef typename RBTree, MapKeyOfT>::const_iterator const_iterator;