846 lines
25 KiB
C++
846 lines
25 KiB
C++
|
#pragma once
|
|||
|
|
|||
|
#include <iostream>
|
|||
|
#include <vector>
|
|||
|
#include <stack>
|
|||
|
#include <queue>
|
|||
|
|
|||
|
namespace Lenyiin
|
|||
|
{
|
|||
|
enum Colour
|
|||
|
{
|
|||
|
RED,
|
|||
|
BLACK
|
|||
|
};
|
|||
|
|
|||
|
template <class K, class V>
|
|||
|
struct RBTreeNode
|
|||
|
{
|
|||
|
RBTreeNode<K, V> *_left;
|
|||
|
RBTreeNode<K, V> *_right;
|
|||
|
RBTreeNode<K, V> *_parent;
|
|||
|
|
|||
|
std::pair<K, V> _kv;
|
|||
|
Colour _colour;
|
|||
|
|
|||
|
RBTreeNode(const std::pair<K, V> &kv)
|
|||
|
: _left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _colour(RED)
|
|||
|
{
|
|||
|
}
|
|||
|
};
|
|||
|
|
|||
|
template <class K, class V>
|
|||
|
class RBTree
|
|||
|
{
|
|||
|
private:
|
|||
|
typedef RBTreeNode<K, V> Node;
|
|||
|
|
|||
|
// 左单旋
|
|||
|
void RotateL(Node *parent)
|
|||
|
{
|
|||
|
Node *ppNode = parent->_parent;
|
|||
|
Node *subR = parent->_right;
|
|||
|
Node *subRL = subR->_left;
|
|||
|
|
|||
|
parent->_right = subRL;
|
|||
|
if (subRL)
|
|||
|
{
|
|||
|
subRL->_parent = parent;
|
|||
|
}
|
|||
|
subR->_left = parent;
|
|||
|
parent->_parent = subR;
|
|||
|
|
|||
|
// 1. 原来 parent 是这棵树的根, 现在 subR 是根
|
|||
|
if (parent == _root)
|
|||
|
{
|
|||
|
_root = subR;
|
|||
|
subR->_parent = nullptr;
|
|||
|
}
|
|||
|
// 2. parent 为根的树只是整棵树中的子树, 改变链接关系, 那么 subR 要顶替他的位置
|
|||
|
else
|
|||
|
{
|
|||
|
if (ppNode->_left == parent)
|
|||
|
{
|
|||
|
ppNode->_left = subR;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
ppNode->_right = subR;
|
|||
|
}
|
|||
|
subR->_parent = ppNode;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// 右单旋
|
|||
|
void RotateR(Node *parent)
|
|||
|
{
|
|||
|
Node *ppNode = parent->_parent;
|
|||
|
Node *subL = parent->_left;
|
|||
|
Node *subLR = subL->_right;
|
|||
|
|
|||
|
parent->_left = subLR;
|
|||
|
if (subLR)
|
|||
|
{
|
|||
|
subLR->_parent = parent;
|
|||
|
}
|
|||
|
subL->_right = parent;
|
|||
|
parent->_parent = subL;
|
|||
|
|
|||
|
if (parent == _root)
|
|||
|
{
|
|||
|
_root = subL;
|
|||
|
subL->_parent = nullptr;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
if (ppNode->_left == parent)
|
|||
|
{
|
|||
|
ppNode->_left = subL;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
ppNode->_right = subL;
|
|||
|
}
|
|||
|
subL->_parent = ppNode;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// 删除整个红黑树
|
|||
|
void DeleteTree(Node *root)
|
|||
|
{
|
|||
|
if (root == nullptr)
|
|||
|
{
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
// 递归删除左子树
|
|||
|
DeleteTree(root->_left);
|
|||
|
// 递归删除右子树
|
|||
|
DeleteTree(root->_right);
|
|||
|
|
|||
|
// 删除当前节点
|
|||
|
delete root;
|
|||
|
}
|
|||
|
|
|||
|
public:
|
|||
|
RBTree(Node *root = nullptr)
|
|||
|
: _root(root)
|
|||
|
{
|
|||
|
}
|
|||
|
|
|||
|
~RBTree()
|
|||
|
{
|
|||
|
DeleteTree(_root);
|
|||
|
}
|
|||
|
|
|||
|
// 1. 空树。插入结点做根,把他变黑。
|
|||
|
// 2. 插入红色节点,他的父亲是黑色的,结束。
|
|||
|
// 3. 插入红色节点,他的父亲是红色的,可以推断他的祖父存在且一定为黑色。关键看叔叔
|
|||
|
// a. 如果叔叔存在且为红,把父亲和叔叔变黑,祖父变红,继续往上处理。
|
|||
|
// b. 如果叔叔存在且为黑,或者不存在。旋转(单旋 or 双旋)+ 变色
|
|||
|
bool Insert(const std::pair<K, V> &kv)
|
|||
|
{
|
|||
|
// 1. 按照搜索树的规则进行插入
|
|||
|
// 如果树为空,直接将新节点设为根节点,并染成黑色
|
|||
|
if (_root == nullptr)
|
|||
|
{
|
|||
|
_root = new Node(kv);
|
|||
|
_root->_colour = BLACK; // 根节点是黑色的
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
// 遍历树找到插入位置
|
|||
|
Node *parent = nullptr;
|
|||
|
Node *cur = _root;
|
|||
|
while (cur)
|
|||
|
{
|
|||
|
if (cur->_kv.first > kv.first)
|
|||
|
{
|
|||
|
parent = cur;
|
|||
|
cur = cur->_left;
|
|||
|
}
|
|||
|
else if (cur->_kv.first < kv.first)
|
|||
|
{
|
|||
|
parent = cur;
|
|||
|
cur = cur->_right;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
return false; // 待插入的节点已经存在
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// 找到位置 插入新节点
|
|||
|
cur = new Node(kv);
|
|||
|
if (parent->_kv.first > kv.first)
|
|||
|
{
|
|||
|
parent->_left = cur;
|
|||
|
cur->_parent = parent;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
parent->_right = cur;
|
|||
|
cur->_parent = parent;
|
|||
|
}
|
|||
|
|
|||
|
// 插入调整
|
|||
|
InsertFixUp(parent, cur);
|
|||
|
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
void InsertFixUp(Node *parent, Node *cur)
|
|||
|
{
|
|||
|
// 调整结点颜色
|
|||
|
// 新结点给红的还是黑的? 红色
|
|||
|
// 1. 空树。插入结点做根, 把他变黑。
|
|||
|
// 2. 插入红色节点, 他的父亲是黑色的, 结束。
|
|||
|
// 3. 插入红色节点, 他的父亲是红色的, 可以推断他的祖父存在且一定为黑色。关键看叔叔
|
|||
|
// a. 如果叔叔存在且为红, 把父亲和叔叔变黑, 祖父变红, 继续往上处理。
|
|||
|
// b. 如果叔叔存在且为黑, 或者不存在。旋转(单旋 or 双旋)+ 变色
|
|||
|
while (parent && parent->_colour == RED)
|
|||
|
{
|
|||
|
// 关键看叔叔
|
|||
|
Node *grandfather = parent->_parent;
|
|||
|
if (grandfather->_left == parent)
|
|||
|
{
|
|||
|
Node *uncle = grandfather->_right;
|
|||
|
|
|||
|
// 情况1: uncle 存在, 且为红
|
|||
|
if (uncle && uncle->_colour == RED)
|
|||
|
{
|
|||
|
parent->_colour = uncle->_colour = BLACK;
|
|||
|
grandfather->_colour = RED;
|
|||
|
|
|||
|
// 继续向上调整
|
|||
|
cur = grandfather;
|
|||
|
parent = cur->_parent;
|
|||
|
}
|
|||
|
// 情况 2 or 情况 3 : uncle 不存在 or uncle 存在且为黑
|
|||
|
else
|
|||
|
{
|
|||
|
// 情况 3: 双旋 -> 变成单旋
|
|||
|
if (cur == parent->_right)
|
|||
|
{
|
|||
|
RotateL(parent);
|
|||
|
std::swap(parent, cur);
|
|||
|
}
|
|||
|
|
|||
|
// 第二种情况 (ps: 有可能是第三种情况变过来的)
|
|||
|
RotateR(grandfather);
|
|||
|
grandfather->_colour = RED;
|
|||
|
parent->_colour = BLACK;
|
|||
|
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
Node *uncle = grandfather->_left;
|
|||
|
|
|||
|
// 情况1: uncle 存在, 且为红
|
|||
|
if (uncle && uncle->_colour == RED)
|
|||
|
{
|
|||
|
parent->_colour = BLACK;
|
|||
|
uncle->_colour = BLACK;
|
|||
|
grandfather->_colour = RED;
|
|||
|
|
|||
|
// 继续向上调整
|
|||
|
cur = grandfather;
|
|||
|
parent = cur->_parent;
|
|||
|
}
|
|||
|
// 情况2 or 情况3: uncle 不存在 or uncle 存在且为黑
|
|||
|
else
|
|||
|
{
|
|||
|
// 情况3: 双旋 -> 变为单旋
|
|||
|
if (cur == parent->_left)
|
|||
|
{
|
|||
|
RotateR(parent);
|
|||
|
std::swap(parent, cur);
|
|||
|
}
|
|||
|
|
|||
|
// 第二种情况 (ps: 有可能是第三种情况变来的)
|
|||
|
RotateL(grandfather);
|
|||
|
grandfather->_colour = RED;
|
|||
|
parent->_colour = BLACK;
|
|||
|
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// 保证根节点为黑色
|
|||
|
_root->_colour = BLACK;
|
|||
|
}
|
|||
|
|
|||
|
// 删除操作
|
|||
|
bool Erase(const K &key)
|
|||
|
{
|
|||
|
// 查找节点
|
|||
|
Node *nodeToDelete = _root;
|
|||
|
while (nodeToDelete)
|
|||
|
{
|
|||
|
if (nodeToDelete->_kv.first > key)
|
|||
|
{
|
|||
|
nodeToDelete = nodeToDelete->_left;
|
|||
|
}
|
|||
|
else if (nodeToDelete->_kv.first < key)
|
|||
|
{
|
|||
|
nodeToDelete = nodeToDelete->_right;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
break; // 找到待删除的节点
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// 如果未找到节点
|
|||
|
if (nodeToDelete == nullptr)
|
|||
|
{
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
// 执行删除操作
|
|||
|
Node *parent, *child;
|
|||
|
Colour originalColour = nodeToDelete->_colour;
|
|||
|
|
|||
|
if (nodeToDelete->_left == nullptr)
|
|||
|
{
|
|||
|
child = nodeToDelete->_right;
|
|||
|
parent = nodeToDelete->_parent;
|
|||
|
Transplant(nodeToDelete, nodeToDelete->_right);
|
|||
|
}
|
|||
|
else if (nodeToDelete->_right == nullptr)
|
|||
|
{
|
|||
|
child = nodeToDelete->_left;
|
|||
|
parent = nodeToDelete->_parent;
|
|||
|
Transplant(nodeToDelete, nodeToDelete->_left);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
Node *successor = Minimum(nodeToDelete->_right);
|
|||
|
originalColour = successor->_colour;
|
|||
|
child = successor->_right;
|
|||
|
if (successor->_parent == nodeToDelete)
|
|||
|
{
|
|||
|
parent = successor;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
Transplant(successor, successor->_right);
|
|||
|
successor->_right = nodeToDelete->_right;
|
|||
|
successor->_right->_parent = successor;
|
|||
|
parent = successor->_parent;
|
|||
|
}
|
|||
|
Transplant(nodeToDelete, successor);
|
|||
|
successor->_left = nodeToDelete->_left;
|
|||
|
successor->_left->_parent = successor;
|
|||
|
successor->_colour = nodeToDelete->_colour;
|
|||
|
}
|
|||
|
|
|||
|
delete nodeToDelete;
|
|||
|
|
|||
|
// 如果删除的节点是黑色,需要进行调整
|
|||
|
if (originalColour == BLACK)
|
|||
|
{
|
|||
|
EraseFixUp(child, parent);
|
|||
|
}
|
|||
|
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
void EraseFixUp(Node *x, Node *parent)
|
|||
|
{
|
|||
|
while (x != _root && (x == nullptr || x->_colour == BLACK))
|
|||
|
{
|
|||
|
if (x == parent->_left)
|
|||
|
{
|
|||
|
Node *w = parent->_right;
|
|||
|
// 情况1: x的兄弟节点w是红色的
|
|||
|
if (w->_colour == RED)
|
|||
|
{
|
|||
|
w->_colour = BLACK;
|
|||
|
parent->_colour = RED;
|
|||
|
RotateL(parent);
|
|||
|
w = parent->_right;
|
|||
|
}
|
|||
|
// 情况2: x的兄弟节点w是黑色的,且w的两个子节点都是黑色的
|
|||
|
if ((w->_left == nullptr || w->_left->_colour == BLACK) &&
|
|||
|
(w->_right == nullptr || w->_right->_colour == BLACK))
|
|||
|
{
|
|||
|
w->_colour = RED;
|
|||
|
x = parent;
|
|||
|
parent = x->_parent;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
// 情况3: w是黑色的,并且w的左子节点是红色,右子节点是黑色
|
|||
|
if (w->_right == nullptr || w->_right->_colour == BLACK)
|
|||
|
{
|
|||
|
if (w->_left)
|
|||
|
w->_left->_colour = BLACK;
|
|||
|
w->_colour = RED;
|
|||
|
RotateR(w);
|
|||
|
w = parent->_right;
|
|||
|
}
|
|||
|
// 情况4: w是黑色的,并且w的右子节点是红色
|
|||
|
if (w)
|
|||
|
{
|
|||
|
w->_colour = parent->_colour;
|
|||
|
parent->_colour = BLACK;
|
|||
|
if (w->_right)
|
|||
|
w->_right->_colour = BLACK;
|
|||
|
RotateL(parent);
|
|||
|
}
|
|||
|
x = _root;
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
Node *w = parent->_left;
|
|||
|
// 情况1: x的兄弟节点w是红色的
|
|||
|
if (w->_colour == RED)
|
|||
|
{
|
|||
|
w->_colour = BLACK;
|
|||
|
parent->_colour = RED;
|
|||
|
RotateR(parent);
|
|||
|
w = parent->_left;
|
|||
|
}
|
|||
|
// 情况2: x的兄弟节点w是黑色的,且w的两个子节点都是黑色的
|
|||
|
if ((w->_left == nullptr || w->_left->_colour == BLACK) &&
|
|||
|
(w->_right == nullptr || w->_right->_colour == BLACK))
|
|||
|
{
|
|||
|
w->_colour = RED;
|
|||
|
x = parent;
|
|||
|
parent = x->_parent;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
// 情况3: w是黑色的,并且w的右子节点是红色,左子节点是黑色
|
|||
|
if (w->_left == nullptr || w->_left->_colour == BLACK)
|
|||
|
{
|
|||
|
if (w->_right)
|
|||
|
{
|
|||
|
w->_right->_colour = BLACK;
|
|||
|
}
|
|||
|
w->_colour = RED;
|
|||
|
RotateL(w);
|
|||
|
w = parent->_left;
|
|||
|
}
|
|||
|
// 情况4: w是黑色的,并且w的左子节点是红色
|
|||
|
if (w)
|
|||
|
{
|
|||
|
w->_colour = parent->_colour;
|
|||
|
parent->_colour = BLACK;
|
|||
|
if (w->_left)
|
|||
|
{
|
|||
|
w->_left->_colour = BLACK;
|
|||
|
}
|
|||
|
RotateR(parent);
|
|||
|
}
|
|||
|
x = _root;
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (x)
|
|||
|
{
|
|||
|
x->_colour = BLACK;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
Node *Minimum(Node *node)
|
|||
|
{
|
|||
|
while (node->_left != nullptr)
|
|||
|
{
|
|||
|
node = node->_left;
|
|||
|
}
|
|||
|
return node;
|
|||
|
}
|
|||
|
|
|||
|
void Transplant(Node *u, Node *v)
|
|||
|
{
|
|||
|
if (u->_parent == nullptr)
|
|||
|
{
|
|||
|
_root = v;
|
|||
|
}
|
|||
|
else if (u == u->_parent->_left)
|
|||
|
{
|
|||
|
u->_parent->_left = v;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
u->_parent->_right = v;
|
|||
|
}
|
|||
|
|
|||
|
if (v != nullptr)
|
|||
|
{
|
|||
|
v->_parent = u->_parent;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// 查找节点
|
|||
|
Node *Find(const K &key)
|
|||
|
{
|
|||
|
Node *cur = _root;
|
|||
|
while (cur)
|
|||
|
{
|
|||
|
if (cur->_kv.first > key)
|
|||
|
{
|
|||
|
cur = cur->_left;
|
|||
|
}
|
|||
|
else if (cur->_kv.first < key)
|
|||
|
{
|
|||
|
cur = cur->_right;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
return cur;
|
|||
|
}
|
|||
|
}
|
|||
|
return nullptr;
|
|||
|
}
|
|||
|
|
|||
|
// 前序遍历的递归实现
|
|||
|
// 辅助函数
|
|||
|
// void _PreOrder(Node *root)
|
|||
|
// {
|
|||
|
// if (root == nullptr)
|
|||
|
// {
|
|||
|
// return;
|
|||
|
// }
|
|||
|
|
|||
|
// // 访问根节点
|
|||
|
// std::cout << root->_kv.first << " (" << (root->_colour == RED ? "RED" : "BLACK") << ") ";
|
|||
|
// _PreOrder(root->_left); // 访问左子树
|
|||
|
// _PreOrder(root->_right); // 访问右子树
|
|||
|
// }
|
|||
|
|
|||
|
// void PreOrder()
|
|||
|
// {
|
|||
|
// std::cout << "前序遍历: ";
|
|||
|
// _PreOrder(_root);
|
|||
|
// std::cout << std::endl;
|
|||
|
// }
|
|||
|
|
|||
|
// 前序遍历的非递归实现
|
|||
|
void PreOrder()
|
|||
|
{
|
|||
|
if (_root == nullptr)
|
|||
|
{
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
std::stack<Node *> stack;
|
|||
|
stack.push(_root);
|
|||
|
|
|||
|
std::cout << "前序遍历: ";
|
|||
|
while (!stack.empty())
|
|||
|
{
|
|||
|
Node *cur = stack.top();
|
|||
|
stack.pop();
|
|||
|
// 访问根节点
|
|||
|
std::cout << cur->_kv.first << " (" << (cur->_colour == RED ? "RED" : "BLACK") << ") ";
|
|||
|
|
|||
|
// 先压入右子树再压入左子树(确保左子树先处理)
|
|||
|
if (cur->_right != nullptr)
|
|||
|
{
|
|||
|
stack.push(cur->_right);
|
|||
|
}
|
|||
|
if (cur->_left != nullptr)
|
|||
|
{
|
|||
|
stack.push(cur->_left);
|
|||
|
}
|
|||
|
}
|
|||
|
std::cout << std::endl;
|
|||
|
}
|
|||
|
|
|||
|
// 中序遍历
|
|||
|
// void _InOrder(Node *root)
|
|||
|
// {
|
|||
|
// if (root == nullptr)
|
|||
|
// {
|
|||
|
// return;
|
|||
|
// }
|
|||
|
|
|||
|
// _InOrder(root->_left);
|
|||
|
// // 访问根节点
|
|||
|
// std::cout << root->_kv.first << " (" << (root->_colour == RED ? "RED" : "BLACK") << ") ";
|
|||
|
// _InOrder(root->_right);
|
|||
|
// }
|
|||
|
|
|||
|
// void InOrder()
|
|||
|
// {
|
|||
|
// std::cout << "中序遍历: ";
|
|||
|
// _InOrder(_root);
|
|||
|
// std::cout << std::endl;
|
|||
|
// }
|
|||
|
|
|||
|
// 中序遍历 非递归
|
|||
|
void InOrder()
|
|||
|
{
|
|||
|
std::stack<Node *> stack;
|
|||
|
Node *cur = _root;
|
|||
|
|
|||
|
std::cout << "中序遍历: ";
|
|||
|
while (cur != nullptr || !stack.empty())
|
|||
|
{
|
|||
|
// 找到最左边的节点
|
|||
|
while (cur != nullptr)
|
|||
|
{
|
|||
|
stack.push(cur);
|
|||
|
cur = cur->_left;
|
|||
|
}
|
|||
|
|
|||
|
// 处理当前节点
|
|||
|
cur = stack.top();
|
|||
|
stack.pop();
|
|||
|
// 访问根节点
|
|||
|
std::cout << cur->_kv.first << " (" << (cur->_colour == RED ? "RED" : "BLACK") << ") ";
|
|||
|
|
|||
|
// 转向右子树
|
|||
|
cur = cur->_right;
|
|||
|
}
|
|||
|
std::cout << std::endl;
|
|||
|
}
|
|||
|
|
|||
|
// 后序遍历的递归实现
|
|||
|
// 辅助函数
|
|||
|
// void _PostOrder(Node *root)
|
|||
|
// {
|
|||
|
// if (root == nullptr)
|
|||
|
// {
|
|||
|
// return;
|
|||
|
// }
|
|||
|
|
|||
|
// _PostOrder(root->_left); // 访问左子树
|
|||
|
// _PostOrder(root->_right); // 访问右子树
|
|||
|
// // 访问根节点
|
|||
|
// std::cout << root->_kv.first << " (" << (root->_colour == RED ? "RED" : "BLACK") << ") ";
|
|||
|
// }
|
|||
|
|
|||
|
// void PostOrder()
|
|||
|
// {
|
|||
|
// std::cout << "后序遍历: ";
|
|||
|
// _PostOrder(_root);
|
|||
|
// std::cout << std::endl;
|
|||
|
// }
|
|||
|
|
|||
|
// 后序遍历的非递归实现
|
|||
|
void PostOrder()
|
|||
|
{
|
|||
|
if (_root == nullptr)
|
|||
|
{
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
std::stack<Node *> st;
|
|||
|
Node *cur = _root;
|
|||
|
Node *lastNode = nullptr; // 最近访问的节点
|
|||
|
std::cout << "后序遍历: ";
|
|||
|
while (cur || !st.empty())
|
|||
|
{
|
|||
|
while (cur)
|
|||
|
{
|
|||
|
st.push(cur);
|
|||
|
cur = cur->_left;
|
|||
|
}
|
|||
|
|
|||
|
Node *top = st.top();
|
|||
|
if ((top->_right == nullptr) || (lastNode == top->_right))
|
|||
|
{
|
|||
|
// 访问当前节点
|
|||
|
std::cout << top->_kv.first << " (" << (top->_colour == RED ? "RED" : "BLACK") << ") ";
|
|||
|
lastNode = top;
|
|||
|
st.pop();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
cur = top->_right;
|
|||
|
}
|
|||
|
}
|
|||
|
std::cout << std::endl;
|
|||
|
}
|
|||
|
|
|||
|
// 层序遍历
|
|||
|
void LevelOrder()
|
|||
|
{
|
|||
|
if (_root == nullptr)
|
|||
|
{
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
std::queue<Node *> queue;
|
|||
|
queue.push(_root);
|
|||
|
|
|||
|
std::cout << "层序遍历: " << std::endl;
|
|||
|
while (!queue.empty())
|
|||
|
{
|
|||
|
int size = queue.size();
|
|||
|
while (size--)
|
|||
|
{
|
|||
|
Node *cur = queue.front();
|
|||
|
queue.pop();
|
|||
|
// 访问当前节点
|
|||
|
std::cout << cur->_kv.first << " (" << (cur->_colour == RED ? "RED" : "BLACK") << ") ";
|
|||
|
|
|||
|
if (cur->_left != nullptr)
|
|||
|
{
|
|||
|
queue.push(cur->_left); // 将左子树压入队列
|
|||
|
}
|
|||
|
if (cur->_right != nullptr)
|
|||
|
{
|
|||
|
queue.push(cur->_right); // 将右子树压入队列
|
|||
|
}
|
|||
|
}
|
|||
|
std::cout << std::endl;
|
|||
|
}
|
|||
|
std::cout << std::endl;
|
|||
|
}
|
|||
|
|
|||
|
// 查找后继节点
|
|||
|
Node *findMin(Node *node)
|
|||
|
{
|
|||
|
while (node->_left != nullptr)
|
|||
|
{
|
|||
|
node = node->_left;
|
|||
|
}
|
|||
|
return node;
|
|||
|
}
|
|||
|
|
|||
|
Node *FindSuccessor(Node *node)
|
|||
|
{
|
|||
|
if (node->_right != nullptr)
|
|||
|
{
|
|||
|
return findMin(node->_right);
|
|||
|
}
|
|||
|
|
|||
|
Node *cur = _root;
|
|||
|
Node *successor = nullptr;
|
|||
|
while (cur != nullptr)
|
|||
|
{
|
|||
|
if (node->_kv.first < cur->_kv.first)
|
|||
|
{
|
|||
|
successor = cur;
|
|||
|
cur = cur->_left;
|
|||
|
}
|
|||
|
else if (node->_kv.first > cur->_kv.first)
|
|||
|
{
|
|||
|
cur = cur->_right;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
return successor;
|
|||
|
}
|
|||
|
|
|||
|
// 查找前驱节点
|
|||
|
Node *findMax(Node *node)
|
|||
|
{
|
|||
|
while (node->_right != nullptr)
|
|||
|
{
|
|||
|
node = node->_right;
|
|||
|
}
|
|||
|
return node;
|
|||
|
}
|
|||
|
|
|||
|
Node *FindPredecessor(Node *node)
|
|||
|
{
|
|||
|
if (node->_left != nullptr)
|
|||
|
{
|
|||
|
return findMax(node->_left);
|
|||
|
}
|
|||
|
|
|||
|
Node *cur = _root;
|
|||
|
Node *predecessor = nullptr;
|
|||
|
while (cur != nullptr)
|
|||
|
{
|
|||
|
if (node->_kv.first < cur->_kv.first)
|
|||
|
{
|
|||
|
cur = cur->_left;
|
|||
|
}
|
|||
|
else if (node->_kv.first > cur->_kv.first)
|
|||
|
{
|
|||
|
predecessor = cur;
|
|||
|
cur = cur->_right;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
return predecessor;
|
|||
|
}
|
|||
|
|
|||
|
// 判断是否是红黑树
|
|||
|
bool IsRBTree()
|
|||
|
{
|
|||
|
// 空树也是红黑树
|
|||
|
if (_root == nullptr)
|
|||
|
{
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
// 1. 根是黑色
|
|||
|
if (_root->_colour != BLACK)
|
|||
|
{
|
|||
|
std::cout << "根节点不是黑色" << std::endl;
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
// 获取任意一条路径上黑色节点的数量
|
|||
|
size_t blackCount = 0;
|
|||
|
Node *cur = _root;
|
|||
|
while (cur)
|
|||
|
{
|
|||
|
if (cur->_colour == BLACK)
|
|||
|
{
|
|||
|
blackCount++;
|
|||
|
}
|
|||
|
cur = cur->_left;
|
|||
|
}
|
|||
|
|
|||
|
// 判断是否满足红黑树的性质, k 用来记录路径中黑色节点的个数
|
|||
|
size_t k = 0;
|
|||
|
return _IsRBTree(_root, k, blackCount);
|
|||
|
}
|
|||
|
|
|||
|
bool _IsRBTree(Node *root, size_t k, size_t blackCount)
|
|||
|
{
|
|||
|
// 走到 nullptr 之后, 判断 k 和 blackCount 是否相等
|
|||
|
if (root == nullptr)
|
|||
|
{
|
|||
|
// 最终黑色节点个数
|
|||
|
if (blackCount != k)
|
|||
|
{
|
|||
|
std::cout << "违反性质四: 每条路径中黑色节点的个数必须相等" << std::endl;
|
|||
|
return false;
|
|||
|
}
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
// 统计黑色节点个数
|
|||
|
if (root->_colour == BLACK)
|
|||
|
{
|
|||
|
k++;
|
|||
|
}
|
|||
|
|
|||
|
// 检测当前节点与其父亲节点是否都为红色
|
|||
|
Node *parent = root->_parent;
|
|||
|
if (parent && parent->_colour == RED && root->_colour == RED)
|
|||
|
{
|
|||
|
std::cout << "违反了性质三: 红色节点的孩子必须是黑色" << std::endl;
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
return _IsRBTree(root->_left, k, blackCount) && _IsRBTree(root->_right, k, blackCount);
|
|||
|
}
|
|||
|
|
|||
|
private:
|
|||
|
Node *_root;
|
|||
|
};
|
|||
|
}
|