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;
|
||
};
|
||
} |