Lenyiin/RBTree
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

博客 https://blog.lenyiin.com/rbtree/ 的代码仓库

Browse Source
This commit is contained in:
Lenyiin 2024-09-19 02:07:52 +08:00
commit 81c191e15f
36 changed files with 3088 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

352
Linux/AVLTree.hpp Normal file
View File

@ -0,0 +1,352 @@
#pragma once
#include <iostream>
using namespace std;
namespace Lenyiin
{
template <class K, class V>
struct AVLTreeNode
{
AVLTreeNode<K, V> *_left;
AVLTreeNode<K, V> *_right;
AVLTreeNode<K, V> *_parent;
int _bf;
pair<K, V> _kv;
// 普通构造
AVLTreeNode(const pair<K, V> &kv)
: _left(nullptr), _right(nullptr), _parent(nullptr), _bf(0), _kv(kv)
{
}
};
template <class K, class V>
class AVLTree
{
private:
typedef AVLTreeNode<K, V> Node;
public:
bool Insert(const pair<K, V> &kv)
{
// 1. 先按搜索树的规则进行插入
if (_root == nullptr)
{
_root = new Node(kv);
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;
}
// 2. 更新平衡因子
while (parent)
{
if (cur == parent->_right)
{
parent->_bf++; // 插在右边，平衡因子++
}
else
{
parent->_bf--; // 插在左边，平衡因子--
}
if (parent->_bf == 0)
{
// 说明 parent 所在的子树的高度不变，更新结束
break;
}
else if (parent->_bf == 1 || parent->_bf == -1)
{
// 说明 parent 所在的子树的高度变了，继续往上更新
cur = parent;
parent = parent->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2)
{
// parent 所在的子树出现问题了，需要旋转处理一下
// 1. 旋转前提是保持它依旧是搜索二叉树
// 2. 旋转成平衡树
if (parent->_bf == 2)
{
if (cur->_bf == 1)
{
// 左旋
RotateL(parent);
}
else if (cur->_bf == -1)
{
// 右左双旋
RotateRL(parent);
}
}
else if (parent->_bf == -2)
{
if (cur->_bf == -1)
{
// 右旋
RotateR(parent);
}
else if (cur->_bf == 1)
{
// 左右双旋
RotateLR(parent);
}
}
// 旋转完成后, parent 所在的树的高度恢复到了，插入节点前高度
// 如果是子树，对上一层没有影响，更新结束
break;
}
}
return true;
}
// 左单旋
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;
}
parent->_bf = subR->_bf = 0;
}
// 右单旋
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;
}
parent->_bf = subL->_bf = 0;
}
// 右左双旋
void RotateRL(Node *parent)
{
Node *subR = parent->_right;
Node *subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == -1)
{
parent->_bf = 0;
subR->_bf = 1;
subRL->_bf = 0;
}
else if (bf == 1)
{
parent->_bf = -1;
subR->_bf = 0;
subRL->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subR->_bf = 0;
subRL->_bf = 0;
}
}
// 左右双旋
void RotateLR(Node *parent)
{
Node *subL = parent->_left;
Node *subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
if (bf == 1)
{
parent->_bf = 0;
subL->_bf = -1;
subLR->_bf = 0;
}
else if (bf == -1)
{
parent->_bf = 1;
subL->_bf = 0;
subLR->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subL->_bf = 0;
subLR->_bf = 0;
}
}
// 中序遍历
void _InOrder(Node *root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
// 获取树的高度
int Height(Node *root)
{
if (root == nullptr)
{
return 0;
}
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
// 判断是否是平衡二叉树
bool _IsBalance(Node *root)
{
if (root == nullptr)
{
return true;
}
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
if (abs(leftHeight - rightHeight) > 1)
{
return false;
}
return _IsBalance(root->_left) && _IsBalance(root->_right);
}
bool IsBalance()
{
return _IsBalance(_root);
}
// 查找
Node *Find(const Node *root)
{
Node *cur = _root;
while (cur)
{
if (cur->_kv.first > root->_kv.first)
{
cur = cur->_left;
}
else if (cur->_kv.first < root->_kv.first)
{
cur = cur->_right;
}
else
{
return cur;
}
}
return nullptr;
}
private:
Node *_root = nullptr;
};
}

100
Linux/Main.cc Normal file
View File

@ -0,0 +1,100 @@
#include "RBTree.hpp"
#include "AVLTree.hpp"
using namespace Lenyiin;
void test_RBTree()
{
// int a[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
int a[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14};
RBTree<int, int> t;
for (const auto &e : a)
{
t.Insert(std::make_pair(e, e));
}
t.PreOrder();
t.InOrder();
t.PostOrder();
t.LevelOrder();
std::cout << "IsRBTree ? " << t.IsRBTree() << std::endl;
auto node = t.Find(5);
if (node != nullptr)
{
std::cout << node->_kv.first << std::endl;
}
else
{
std::cout << "没找到" << std::endl;
}
auto pre = t.FindPredecessor(node);
if (pre != nullptr)
{
std::cout << node->_kv.first << " 的前驱节点是: " << pre->_kv.first << std::endl;
}
else
{
std::cout << "前驱节点为空" << std::endl;
}
auto suc = t.FindSuccessor(node);
if (suc != nullptr)
{
std::cout << node->_kv.first << " 的后继节点是: " << suc->_kv.first << std::endl;
}
else
{
std::cout << "后继节点为空" << std::endl;
}
t.Erase(7);
t.LevelOrder();
std::cout << "IsRBTree ? " << t.IsRBTree() << std::endl;
t.Erase(15);
t.LevelOrder();
std::cout << "IsRBTree ? " << t.IsRBTree() << std::endl;
}
void testRB_AVLTree()
{
const int n = 100000;
std::vector<int> v;
v.reserve(n);
srand(time(0));
for (size_t i = 0; i < n; i++)
{
v.push_back(rand());
}
RBTree<int, int> rbtree;
AVLTree<int, int> avltree;
size_t begin1 = clock();
for (const auto &e : v)
{
rbtree.Insert(std::make_pair(e, e));
}
size_t end1 = clock();
size_t begin2 = clock();
for (const auto &e : v)
{
avltree.Insert(std::make_pair(e, e));
}
size_t end2 = clock();
std::cout << "红黑树测试时间：" << end1 - begin1 << std::endl;
std::cout << "AVL 测试时间：\t" << end2 - begin2 << std::endl;
}
int main()
{
test_RBTree();
testRB_AVLTree();
return 0;
}

6
Linux/Makefile Normal file
View File

@ -0,0 +1,6 @@
main:Main.cc
g++ -o $@ $^
.PHONY:clean
clean:
rm -f main

846
Linux/RBTree.hpp Normal file
View File

@ -0,0 +1,846 @@
#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;
};
}

BIN
Linux/main Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/.vs/Windows_RBTree/FileContentIndex/1b38c67f-c22c-4867-9077-9a4f8c40279c.vsidx Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/.vs/Windows_RBTree/FileContentIndex/5b59df87-c407-4a5f-bf1d-88aaff741cd0.vsidx Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/.vs/Windows_RBTree/FileContentIndex/aabd876c-f266-4362-bd2b-af81b54715f4.vsidx Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/.vs/Windows_RBTree/FileContentIndex/e9508898-ea9c-42fc-a2f7-193c370f1a41.vsidx Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/.vs/Windows_RBTree/v17/.suo Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/.vs/Windows_RBTree/v17/Browse.VC.db Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/.vs/Windows_RBTree/v17/ipch/AutoPCH/b04414422c149ba9/RBTREE.ipch Normal file
View File

Binary file not shown.

612
Windows_RBTree/AVLTree.hpp Normal file
View File

@ -0,0 +1,612 @@
#pragma once
#include <iostream>
#include <stack>
#include <queue>
namespace Lenyiin
{
template <class K, class V>
struct AVLTreeNode
{
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf; // balance factor 平衡因子
std::pair<K, V> _kv; // key-value
// 普通构造
AVLTreeNode(const std::pair<K, V>& kv)
: _left(nullptr), _right(nullptr), _parent(nullptr), _bf(0), _kv(kv)
{
}
};
template <class K, class V>
class AVLTree
{
private:
typedef AVLTreeNode<K, V> Node;
public:
bool Insert(const std::pair<K, V>& kv)
{
// 1. 先按搜索树的规则进行插入
if (_root == nullptr)
{
_root = new Node(kv);
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;
}
// 2. 更新平衡因子
while (parent)
{
if (cur == parent->_right)
{
parent->_bf++; // 插在右边, 平衡因子++
}
else
{
parent->_bf--; // 插在左边, 平衡因子--
}
if (parent->_bf == 0)
{
// 说明 parent 所在的子树高度不变, 更新结束
break;
}
else if (parent->_bf == 1 || parent->_bf == -1)
{
// 说明 parent 所在子树的高度变了, 继续往上更新
cur = parent;
parent = parent->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2)
{
// parent 所在的子树出现问题了, 需要旋转处理一下
// 1. 旋转前提是保持它依旧是搜索二叉树
// 2. 旋转成平衡树
if (parent->_bf == 2)
{
if (cur->_bf == 1)
{
// 左旋
RotateL(parent);
}
else if (cur->_bf == -1)
{
// 右左双旋
RotateRL(parent);
}
}
else if (parent->_bf == -2)
{
if (cur->_bf == -1)
{
// 右旋
RotateR(parent);
}
else if (cur->_bf == 1)
{
// 左右双旋
RotateLR(parent);
}
}
// 旋转完成后, parent 所在的树的高度恢复到了插入节点前的高度
// 如果是子树, 对上一层没有影响, 更新结束
break;
}
}
return true;
}
// 左单旋
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;
}
parent->_bf = subR->_bf = 0;
}
// 右单旋
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;
}
parent->_bf = subL->_bf = 0;
}
// 右左双旋
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == -1)
{
parent->_bf = 0;
subR->_bf = 1;
subRL->_bf = 0;
}
else if (bf == 1)
{
parent->_bf = -1;
subR->_bf = 0;
subRL->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subR->_bf = 0;
subRL->_bf = 0;
}
}
// 左右双旋
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
if (bf == 1)
{
parent->_bf = 0;
subL->_bf = -1;
subLR->_bf = 0;
}
else if (bf == -1)
{
parent->_bf = 1;
subL->_bf = 0;
subLR->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subL->_bf = 0;
subLR->_bf = 0;
}
}
// 中序遍历
// void _InOrder(Node* root)
//{
// if (root == nullptr)
// {
// return;
// }
// _InOrder(root->_left);
// std::cout << root->_kv.first << ":" << root->_kv.second << std::endl;
// _InOrder(root->_right);
//}
// void InOrder()
//{
// _InOrder(_root);
// std::cout << std::endl;
// }
// 中序遍历 非递归
void InOrder()
{
std::stack<Node*> stack;
Node* cur = _root;
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->_kv.second << std::endl;
// 转向右子树
cur = cur->_right;
}
std::cout << std::endl;
}
// 前序遍历的递归实现
// 辅助函数
// void _PreOrder(Node* root)
//{
// if (root == nullptr)
// {
// return;
// }
// std::cout << root->_kv.first << ":" << root->_kv.second << std::endl; // 访问根节点
// _PreOrder(root->_left); // 访问左子树
// _PreOrder(root->_right); // 访问右子树
//}
// void PreOrder()
//{
// _PreOrder(_root);
// std::cout << std::endl;
// }
// 前序遍历的非递归实现
void PreOrder()
{
if (_root == nullptr)
{
return;
}
std::stack<Node*> stack;
stack.push(_root);
while (!stack.empty())
{
Node* cur = stack.top();
stack.pop();
std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl; // 访问当前节点
// 先压入右子树再压入左子树（确保左子树先处理）
if (cur->_right != nullptr)
{
stack.push(cur->_right);
}
if (cur->_left != nullptr)
{
stack.push(cur->_left);
}
}
std::cout << std::endl;
}
// 后序遍历的递归实现
// 辅助函数
// void _PostOrder(Node* root) {
// if (root == nullptr)
// {
// return;
// }
// _PostOrder(root->_left); // 访问左子树
// _PostOrder(root->_right); // 访问右子树
// std::cout << root->_kv.first << ":" << root->_kv.second << std::endl; // 访问根节点
//}
// void PostOrder()
//{
// _PostOrder(_root);
// std::cout << std::endl;
// }
// 后序遍历的非递归实现
void PostOrder()
{
if (_root == nullptr)
{
return;
}
std::stack<Node*> st;
Node* cur = _root;
Node* lastNode = nullptr; // 最近访问的节点
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->_kv.second << std::endl;
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);
while (!queue.empty())
{
Node* cur = queue.front();
queue.pop();
std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl; // 访问当前节点
if (cur->_left != nullptr)
{
queue.push(cur->_left); // 将左子树压入队列
}
if (cur->_right != nullptr)
{
queue.push(cur->_right); // 将右子树压入队列
}
}
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;
}
// 获取树的高度
int Height(Node* root)
{
if (root == nullptr)
{
return 0;
}
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
// 判断是否是平衡二叉树
bool _IsBalance(Node* root)
{
if (root == nullptr)
{
return true;
}
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
if (abs(leftHeight - rightHeight) > 1)
{
return false;
}
return _IsBalance(root->_left) && _IsBalance(root->_right);
}
bool IsBalance()
{
return _IsBalance(_root);
}
// 查找 非递归
// 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;
//}
// 查找的递归实现
// 辅助函数
Node* _find(Node* root, const K& key)
{
if (root == nullptr || root->_kv.first == key)
{
return root;
}
if (key < root->_kv.first)
{
return _find(root->_left, key);
}
else
{
return _find(root->_right, key);
}
}
// 查找节点
Node* Find(const K& key)
{
return _find(_root, key);
}
private:
Node* _root = nullptr;
};
}

100
Windows_RBTree/RBTree.cpp Normal file
View File

@ -0,0 +1,100 @@
#include "RBTree.hpp"
#include "AVLTree.hpp"
using namespace Lenyiin;
void test_RBTree()
{
// int a[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
RBTree<int, int> t;
for (const auto& e : a)
{
t.Insert(std::make_pair(e, e));
}
t.PreOrder();
t.InOrder();
t.PostOrder();
t.LevelOrder();
std::cout << "IsRBTree ? " << t.IsRBTree() << std::endl;
auto node = t.Find(5);
if (node != nullptr)
{
std::cout << node->_kv.first << std::endl;
}
else
{
std::cout << "没找到" << std::endl;
}
auto pre = t.FindPredecessor(node);
if (pre != nullptr)
{
std::cout << node->_kv.first << " 的前驱节点是: " << pre->_kv.first << std::endl;
}
else
{
std::cout << "前驱节点为空" << std::endl;
}
auto suc = t.FindSuccessor(node);
if (suc != nullptr)
{
std::cout << node->_kv.first << " 的后继节点是: " << suc->_kv.first << std::endl;
}
else
{
std::cout << "后继节点为空" << std::endl;
}
t.Erase(7);
t.LevelOrder();
std::cout << "IsRBTree ? " << t.IsRBTree() << std::endl;
t.Erase(15);
t.LevelOrder();
std::cout << "IsRBTree ? " << t.IsRBTree() << std::endl;
}
void testRB_AVLTree()
{
const int n = 100000;
std::vector<int> v;
v.reserve(n);
srand(time(0));
for (size_t i = 0; i < n; i++)
{
v.push_back(rand());
}
RBTree<int, int> rbtree;
AVLTree<int, int> avltree;
size_t begin1 = clock();
for (const auto& e : v)
{
rbtree.Insert(std::make_pair(e, e));
}
size_t end1 = clock();
size_t begin2 = clock();
for (const auto& e : v)
{
avltree.Insert(std::make_pair(e, e));
}
size_t end2 = clock();
std::cout << "红黑树测试时间：" << end1 - begin1 << std::endl;
std::cout << "AVL 测试时间：\t" << end2 - begin2 << std::endl;
}
int main()
{
test_RBTree();
testRB_AVLTree();
return 0;
}

846
Windows_RBTree/RBTree.hpp Normal file
View File

@ -0,0 +1,846 @@
#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;
};
}

31
Windows_RBTree/Windows_RBTree.sln Normal file
View File

@ -0,0 +1,31 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.7.34221.43
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Windows_RBTree", "Windows_RBTree.vcxproj", "{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Debug|x64.ActiveCfg = Debug|x64
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Debug|x64.Build.0 = Debug|x64
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Debug|x86.ActiveCfg = Debug|Win32
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Debug|x86.Build.0 = Debug|Win32
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Release|x64.ActiveCfg = Release|x64
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Release|x64.Build.0 = Release|x64
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Release|x86.ActiveCfg = Release|Win32
{42DB53E7-EF25-40D3-BFC1-32390B8ED7F0}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {373424CD-AADC-4D9C-B61E-7D43BD7C3183}
EndGlobalSection
EndGlobal

139
Windows_RBTree/Windows_RBTree.vcxproj Normal file
View File

@ -0,0 +1,139 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>17.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{42db53e7-ef25-40d3-bfc1-32390b8ed7f0}</ProjectGuid>
<RootNamespace>WindowsRBTree</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="RBTree.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="AVLTree.hpp" />
<ClInclude Include="RBTree.hpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

30
Windows_RBTree/Windows_RBTree.vcxproj.filters Normal file
View File

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="源文件">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="头文件">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
</Filter>
<Filter Include="资源文件">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="RBTree.cpp">
<Filter>源文件</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="RBTree.hpp">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="AVLTree.hpp">
<Filter>头文件</Filter>
</ClInclude>
</ItemGroup>
</Project>

4
Windows_RBTree/Windows_RBTree.vcxproj.user Normal file
View File

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>

BIN
Windows_RBTree/x64/Debug/RBTree.obj Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.exe Normal file
View File

Binary file not shown.

11
Windows_RBTree/x64/Debug/Windows_RBTree.exe.recipe Normal file
View File

@ -0,0 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<Project>
<ProjectOutputs>
<ProjectOutput>
<FullPath>E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\x64\Debug\Windows_RBTree.exe</FullPath>
</ProjectOutput>
</ProjectOutputs>
<ContentFiles />
<SatelliteDlls />
<NonRecipeFileRefs />
</Project>

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.ilk Normal file
View File

Binary file not shown.

7
Windows_RBTree/x64/Debug/Windows_RBTree.log Normal file
View File

@ -0,0 +1,7 @@
 RBTree.cpp
E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\RBTree.cpp(67,15): warning C4244: “参数”: 从“time_t”转换到“unsigned int”，可能丢失数据
E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\RBTree.hpp(681,26): warning C4267: “初始化”: 从“size_t”转换到“int”，可能丢失数据
E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\RBTree.hpp(668,14): message : 在编译 类 模板 成员函数“void Lenyiin::RBTree<int,int>::LevelOrder(void)”时
E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\RBTree.cpp(19,17): message : 请参阅 "test_RBTree" 中对 "Lenyiin::RBTree<int,int>::LevelOrder" 的第一个引用
E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\RBTree.cpp(10,22): message : 查看对正在编译的 类 模板 实例化“Lenyiin::RBTree<int,int>”的引用
Windows_RBTree.vcxproj -> E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\x64\Debug\Windows_RBTree.exe

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.pdb Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/CL.command.1.tlog Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/CL.read.1.tlog Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/CL.write.1.tlog Normal file
View File

Binary file not shown.

1
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/Cl.items.tlog Normal file
View File

@ -0,0 +1 @@
E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\RBTree.cpp;E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\x64\Debug\RBTree.obj

2
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/Windows_RBTree.lastbuildstate Normal file
View File

@ -0,0 +1,2 @@
PlatformToolSet=v143:VCToolArchitecture=Native64Bit:VCToolsVersion=14.37.32822:TargetPlatformVersion=10.0.22000.0:
Debug|x64|E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\|

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/link.command.1.tlog Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/link.read.1.tlog Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/x64/Debug/Windows_RBTree.tlog/link.write.1.tlog Normal file
View File

Binary file not shown.

1
Windows_RBTree/x64/Debug/Windows_RBTree.vcxproj.FileListAbsolute.txt Normal file
View File

@ -0,0 +1 @@
E:\Git 仓库\公开仓库\8_RBTree\Windows_RBTree\x64\Debug\Windows_RBTree.exe

BIN
Windows_RBTree/x64/Debug/vc143.idb Normal file
View File

Binary file not shown.

BIN
Windows_RBTree/x64/Debug/vc143.pdb Normal file
View File

Binary file not shown.