用红黑树封装map和set
文章目录:
- 红黑树模拟实现完整代码
- 红黑树参数适配改造
- 仿函数
- 正向迭代器
- 反向迭代器
- 红黑树封装后的代码
- map完整代码
- set完整代码
红黑树模拟实现完整代码
如下是红黑树kv模型的模拟实现完整代码，现在我们需要基于此代码封装出map和set基本的接口实现。
#pragma once
#include红黑树参数适配改造
这里我们需要用同一棵红黑树来实现map和set，但是map是kv模型，而set是key模型。我们实现的红黑树是kv模型，为了同时适配k的模型，我们需要对红黑树的模板参数做一些处理。
- 这里需要控制 map 和 set 传入红黑树底层结构的模板参数，为了与之前的 kv 模型参数进行区分，将红黑树的第二个模板参数改为T。则T参数可能存储键值 key，也有可能存储键值对 key-value。
- map 传递给红黑树的T模板参数是 pair
template<class K>
class set
{
private:
RBTree<K, K> _t;
};
template<class K,class V>
class map
{
private:
RBTree<K, pair<const K,V>> _t;
};
❓为什么不去掉红黑树的第一个模板参数，只保留第二个模板参数呢？
不能！红黑树中的第二个模板参数是一个键值对，对于 set 容器来说，省略红黑树第一个模板参数是没有任何问题的，但是对于 map 容器而言，若去掉红黑树的第二个模板参数，那么就无法得到 key 的类型，像 find、erase 这样的接口中是需要键值 key 的，所以第一个模板参数不能够省略。
仿函数
红黑树中的模板参数T可能是 key ，也可能是
当上层容器是 set 时，红黑树中的 T 就是键值 key ，因此 set 的仿函数直接返回 K 值就可以了。
template<class K>
class set
{
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
private:
RBTree<K, K, SetKeyOfT> _t;
};
当上层容器是 map 时，红黑树中的 T 储存的就是键值对 pair
template<class K,class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
private:
RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};
✅仿函数应该如何使用呢？以下我们以红黑树的查找为例来看看仿函数的使用方法：
iterator find(const K& key)
{
KeyOfT kot; // 定义一个仿函数对象
Node* cur = _root;
while (cur)
{
if (kot(cur->_data) < key) // 利用仿函数对象去取_data中用来进行比较的参数
cur = cur->_right;
else if (kot(cur->_data) > key)
cur = cur->_left;
else
return iterator(cur);
}
return end();
}
正向迭代器
✔️红黑树的迭代器即对红黑树中节点指针进行封装，便于使用。
// 正向迭代器
template<class T,class Ref,class Ptr>
struct __TreeIterator
{
typedef Ref reference;
typedef Ptr pointer;
typedef RBTreeNode<T> Node; // 重定义节点的类型
typedef __TreeIterator<T, Ref, Ptr> Self; // 迭代器类型
Node* _node; // 迭代器封装节点指针
__TreeIterator(Node* node) // 迭代器的构造函数
:_node(node)
{}
}
✔️对正向迭代器进行解引用操作，只需要返回对应节点的数据即可。使用 -> 操作时，只需返回对应节点数据指针即可。
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;
}
✔️红黑树正向迭代器找到下一个节点需要进行++操作，应该根据红黑树中序遍历的序列找到当前节点的下一个节点。
实现红黑树正向迭代器时，当前节点进行 ++ 操作后，应该根据红黑树中序遍历的序列找到当前节点的下一个节点。
++ 操作的具体步骤：
- 若当前节点的右子树不为空，则 ++ 之后应是其右子树中的最左节点。
- 若当前节点的右子树为空，则 ++ 之后应是该节点的祖先节点中，孩子不在父节点右的祖先。
实现代码：
Self operator++()
{
if (_node->_right) // 当前节点的右子树不为空
{
// 找到右子树中的最左节点 - 即右子树中中序的第一个节点
Node* left = _node->_right;
while (left->_left)
{
left = left->_left;
}
_node = left;
}
else // 当前节点右子树为空
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && parent->_right == cur)
{
cur = cur->_parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
✔️红黑树迭代器中 - - 的实现恰好与 ++ 相反，根据红黑树中序遍历序列找到当前节点的前一个节点。
- - 操作的具体步骤：
- 若当前节点的左子树不为空，则 - - 之后应是其左子树中的最右节点。
- 若当前节点的左子树为空，则 - - 之后应是该节点的祖先节点中，孩子不在父节点左的祖先。
实现代码：
Self& operator--()
{
if (_node->_left)
{
// 左子树的最右节点
Node* right = _node->_left;
while (right->_right)
{
right = right->_right;
}
_node = right;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && cur == parent->_left)
{
cur = parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
注意： 此处的 ++ 操作和 - - 操作和STL中的实现是不一样的，相对库里面的实现是有差距的，这里只是一个简单的模拟。想要看STL库里面的实现可以去查一下。
正向迭代器完整代码：
template<class T,class Ref,class Ptr>
struct __TreeIterator
{
typedef Ref reference;
typedef Ptr pointer;
typedef RBTreeNode<T> Node;
typedef __TreeIterator<T, Ref, Ptr> Self;
Node* _node;
__TreeIterator(Node* node)
:_node(node)
{}
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;
}
Self operator++()
{
if (_node->_right) // 当前节点的右子树不为空
{
// 找到右子树中的最左节点 - 即右子树中中序的第一个节点
Node* left = _node->_right;
while (left->_left)
{
left = left->_left;
}
_node = left;
}
else // 当前节点右子树为空
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && parent->_right == cur)
{
cur = cur->_parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
Self& operator--()
{
if (_node->_left)
{
// 左子树的最右节点
Node* right = _node->_left;
while (right->_right)
{
right = right->_right;
}
_node = right;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent && cur == parent->_left)
{
cur = parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
};
反向迭代器
红黑树的反向迭代器是由正向迭代器封装的，因此红黑树的反向迭代器也是一个迭代器适配器。和之前学习的 priority_queue、stack、queue 都是属于适配器。
// 反向迭代器 - 迭代器适配器
template<class Iterator>
struct ReverseIterator
{
typedef typename Iterator::reference Ref; // 节点指针的引用
typedef typename Iterator::pointer Ptr; // 节点指针
typedef typename ReverseIterator<Iterator> Self; // 反向迭代器类型
ReverseIterator(Iterator it)
:_it(it) // 用正向迭代器封装一个反向迭代器
{}
Ref operator*()
{
return *_it; // 调用正向迭代器的operator* 返回节点数据的引用
}
Ptr operator->()
{
return _it.operator->(); // 调用正向迭代器的operator-> 返回节点数据指针
}
Self& operator++()
{
--_it; // 调用正向迭代器的 --
return *this;
}
Self& operator--()
{
++_it; // 调用正向迭代器的 ++
return *this;
}
bool operator==(const Self& s)const
{
return _it == s._it;
}
bool operator!=(const Self& s)const
{
return _it != s._it;
}
Iterator _it;
};
☃️反向迭代器只有一个模板参数，即正向迭代器的类型。因此反向迭代器是不知道节点的引用类型和节点的指针类型的，这时我们需要对正向迭代器中这两个类型进行 typedef ，则反向迭代器可通过正向迭代器获取节点引用类型和节点指针类型。
template<class T,class Ref,class Ptr>
struct __TreeIterator
{
typedef Ref reference; // 节点指针引用
typedef Ptr pointer; // 节点指针
}
红黑树封装后的代码
#pragma once
#includemap完整代码
template<class K,class V>
class map
{
struct MapKeyOfT
{
const K& operator()(const pair<const 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>::reverse_iterator reverse_iterator;
reverse_iterator rbegin()
{
return _t.rbegin();
}
reverse_iterator rend()
{
return _t.rend();
}
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
pair<iterator, bool> insert(const pair<const K, V>& kv)
{
return _t.insert(kv);
}
// []的运算符重载
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
void erase(const K& k)
{
return _t.erase();
}
iterator find(const K& k)
{
return _t.find();
}
private:
RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};
set完整代码
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>::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& k)
{
return _t.insert(k);
}
void erase(const K& k)
{
return _t.erase(k);
}
iterator find(const K& k)
{
return _t.find(k);
}
private:
RBTree<K, K, SetKeyOfT> _t;
};
说明： 我们对 map 和 set 进行模拟实现只是为了让我们更加了解它们的框架和红黑树的底层实现原理。