#pragma once
#ifndef RTREE
#define RTREE
#define RED 0
#define BLACK 1
#include<ctime>
#include<iostream>
template<class Type>
class RBTreeNode {
public:
unsigned int color = -1;
Type key;
RBTreeNode <Type>* left;
RBTreeNode <Type>* right;
RBTreeNode <Type>* parent;
RBTreeNode(Type key, int color, RBTreeNode<Type> * parent, RBTreeNode<Type> * left, RBTreeNode<Type>* right) :key(key),color(color),parent(parent),
left(left),right(right)
{};
};
template<class Type>
class RBTree {
public:
RBTreeNode<Type> * m_root;
RBTree() {
m_root = NULL;
}
~RBTree() {
rbtree_destroy();
}
bool insert_rbtree(Type key);
void delete_rbtree(Type key);
void print_rbtree();
RBTreeNode<Type>* rb_parent(RBTreeNode<Type>* node);
bool isRedNode(RBTreeNode<Type>* node);
bool isBlackNode(RBTreeNode<Type>* node);
RBTreeNode<Type>* search(RBTreeNode<Type>*x, Type key);
bool rbtree_search(Type key);
void preOrder(RBTreeNode<Type>* tree);
void InOrder(RBTreeNode<Type>* tree);
void preOrder_rbtree();
void InOrder_rbtree();
private:
void rbtree_print(RBTreeNode<Type>*tree, Type key, int direction);
void destroyTree(RBTreeNode<Type>* tree);
void rbtree_destroy();
void rbtree_insert(RBTreeNode<Type>*&root, RBTreeNode<Type>*newNode);
void rebtree_insert_fixup(RBTreeNode<Type>*&root, RBTreeNode<Type>* node);
void rbtree_left_rotate(RBTreeNode<Type>*&root, RBTreeNode <Type>* x);
void rbtree_right_rotate(RBTreeNode<Type>*&root, RBTreeNode <Type>* x);
void rbtree_delete(RBTreeNode<Type>*&root, RBTreeNode<Type>*newNode);
void rebtree_delete_fixup(RBTreeNode<Type>*&root, RBTreeNode<Type>* node, RBTreeNode<Type>* parent);
};
#endif
#include"BTREE.h"
using namespace std;
template<class Type>
void RBTree<Type>::rbtree_left_rotate(RBTreeNode<Type>*&root, RBTreeNode<Type>* x) {
RBTreeNode <Type>* y = x->right;
x->right = y->left;
if (y->left != NULL) y->left->parent = x;
y->parent = x->parent;
if (x->parent == NULL) {
root = y;
}
else {
if (x->parent->left == x)
x->parent->left = y;
else
x->parent->right = y;
}
x->parent = y;
y->left = x;
}
template<class Type>
void RBTree<Type>::rbtree_right_rotate(RBTreeNode<Type>* &root, RBTreeNode<Type>* x) {
RBTreeNode <Type>* y = x->left;
x->left = y->right;
if (y->right != NULL) y->right->parent = x;
y->parent = x->parent;
if (x->parent == NULL) {
root= y;
}
else {
if (x->parent->left == x) {
x->parent->left = y;
}
else {
x->parent->right = y;
}
}
y->right = x;
x->parent = y;
}
template<class Type>
RBTreeNode<Type>* RBTree<Type>::rb_parent(RBTreeNode<Type>* node) {
if (node && node->parent)
return node->parent;
else return NULL;
}
template<class Type>
bool RBTree<Type>::isRedNode(RBTreeNode<Type>* node) {
return node->color == RED;
}
template<class Type>
bool RBTree<Type>::isBlackNode(RBTreeNode<Type>* node){
return node->color == BLACK;
}
template<class Type>
RBTreeNode<Type>* RBTree<Type> ::search(RBTreeNode<Type>*x, Type key)
{
if (x == NULL || x->key == key)
return x;
if (key < x->key)
return search(x->left, key);
else
return search(x->right, key);
}
template<class Type>
bool RBTree<Type> ::rbtree_search( Type key)
{
if (m_root)
return search(m_root, key) ? true : false;
else
cout << key << "不存在" << endl;
return false;
}
template<class Type>
void RBTree<Type>::rbtree_insert(RBTreeNode<Type>*&root, RBTreeNode<Type>*newNode) {
RBTreeNode<Type>*y = NULL;
RBTreeNode<Type>*x = root;
while (x != NULL) {
y = x;
if (newNode->key < x->key) { x = x->left; }
else x = x->right;
}
newNode->parent = y;
if (y != NULL) {
if (newNode->key < y->key)
y->left = newNode;
else
y->right = newNode;
}
else {
root = newNode;
}
newNode->color = RED;
rebtree_insert_fixup(root,newNode);
}
template<class Type>
void RBTree<Type>::rebtree_insert_fixup(RBTreeNode<Type>*&root, RBTreeNode<Type>* node) {
RBTreeNode<Type> *parent, *grandparent;
while ((parent = node->parent) && isRedNode(parent)) {
grandparent = parent->parent;
if (parent == grandparent->left) {
RBTreeNode<Type> *uncle = grandparent->right;
if (uncle&&isRedNode(uncle)) {
uncle->color = parent->color = BLACK;
grandparent->color = RED;
node = grandparent;
continue;
}
else {
if (parent->right == node) {
rbtree_left_rotate(root, parent);
RBTreeNode<Type> * temp = parent;
parent = node;
node = temp;
}
else {
}
parent->color = BLACK;
grandparent->color = RED;
rbtree_right_rotate(root, grandparent);
}
}
else {
RBTreeNode<Type> *uncle = grandparent->left;
if (uncle && isRedNode(uncle)) {
uncle->color = parent->color = BLACK;
grandparent->color = RED;
node = grandparent;
continue;
}
else {
if (parent->left == node) {
rbtree_right_rotate(root, parent);
RBTreeNode<Type> * temp = parent;
parent = node;
node = temp;
}
parent->color = BLACK;
grandparent->color = RED;
rbtree_left_rotate(root, grandparent);
}
}
}
root->color = BLACK;
}
template<class Type>
bool RBTree<Type> ::insert_rbtree(Type key)
{
RBTreeNode<Type>* node =NULL;
if (search(m_root, key))
return false;
if ( ( node= new RBTreeNode<Type>(key, BLACK, NULL, NULL, NULL))== NULL)
return false;
rbtree_insert( m_root,node);
cout << endl;
print_rbtree();
cout << endl;
return true;
}
template<class Type>
void RBTree<Type> ::rbtree_print(RBTreeNode<Type>*tree, Type key, int direction)
{
if (tree != NULL)
{
if (direction == 0)
printf("%2d(B) is root\n", tree->key);
else
printf("%2d(%s) is %2d's %6s child\n", tree->key, isRedNode(tree) ? "R" : "B", key, direction == 1 ? "right" : "left");
rbtree_print(tree->left, tree->key, -1);
rbtree_print(tree->right, tree->key, 1);
}
}
template<class Type>
void RBTree<Type> ::print_rbtree()
{
if (m_root != NULL )
rbtree_print(m_root, m_root->key, 0);
else
cout << "为空树" << endl;
}
template<class Type>
void RBTree<Type>::destroyTree(RBTreeNode<Type>* tree) {
if (!tree) return;
if (tree->left)destroyTree(tree->left);
if (tree->right)destroyTree(tree->right);
delete tree;
}
template<class Type>
void RBTree<Type>::rbtree_destroy() {
if (m_root != NULL) {
destroyTree(m_root);
cout << "delete finished." << endl;
}
delete m_root;
}
template<class Type>
void RBTree<Type>::rbtree_delete( RBTreeNode<Type>*&root, RBTreeNode<Type>*node) {
RBTreeNode<Type>* child = NULL;
RBTreeNode<Type>* parent;
int color = -1;
if ((node->right != NULL) && (node->left != NULL)) {
RBTreeNode<Type>* rChild;
RBTreeNode<Type>* replace = node->right;
while (replace->left != NULL) {
replace = replace->left;
}
if (node->parent != NULL) {
if (node->parent->left == node) {
node->parent->left = replace;
}
else
node->parent->right = replace;
}
else root = replace;
int color = replace->color;
rChild = replace->right;
parent = replace->parent;
if (parent == node) {
parent = replace;
}
else {
if (rChild) {
rChild->parent = parent;
}
parent->left = rChild;
replace->right = node->right;
node->right->parent = replace;
}
replace->color = node->color;
replace->parent = node->parent;
replace->left = node->left;
node->left->parent = replace;
if (color == BLACK) {
rebtree_delete_fixup(root, rChild, parent);
}
delete node;
return;
}
color = node->color;
parent = node->parent;
if (node->right != NULL)
child = node->right;
else
child = node->left;
if (child) {
child->parent = parent;
}
if (parent) {
if (parent->left == node) {
parent->left = child;
}
else {
parent->right = child;
}
}
else {
root = child;
}
if (color == BLACK) {
rebtree_delete_fixup(root, child, parent);
}
delete node;
}
template<class Type>
void RBTree<Type>::rebtree_delete_fixup(RBTreeNode<Type>*&root, RBTreeNode<Type>*node, RBTreeNode<Type>* parent) {
RBTreeNode<Type>* broNode;
while ((!node || isBlackNode(node)) && node != root) {
if (node == parent->left) {
broNode = parent->right;
if (isRedNode(broNode)) {
broNode->color = BLACK;
parent->color = RED;
rbtree_left_rotate(root, parent);
broNode = parent->right;
}
if ((!broNode->right || isBlackNode(broNode->right)) &&
(!broNode->left || isBlackNode(broNode->left))) {
broNode->color = RED;
node = parent;
parent = node->parent;
}
else {
if (!broNode->right || isBlackNode(broNode->right)) {
broNode->left->color = BLACK;
broNode->color = RED;
rbtree_right_rotate(root, broNode);
broNode = parent->right;
}
broNode->color = node->parent->color;
parent->color = BLACK;
broNode->right->color = BLACK;
rbtree_left_rotate(root, parent);
node = root;
break;
}
}
else {
broNode = parent->left;
if (isRedNode(broNode)) {
broNode->color = BLACK;
parent->color = RED;
rbtree_right_rotate(root, parent);
broNode = parent->left;
}
if ((!broNode->right || isBlackNode(broNode->right)) &&
(!broNode->left || isBlackNode(broNode->left))) {
broNode->color = RED;
node = parent;
parent = node->parent;
}
else {
if (!broNode->left || isBlackNode(broNode->left)) {
broNode->right->color = BLACK;
broNode->color = RED;
rbtree_left_rotate(root, broNode);
broNode = parent->left;
}
broNode->color = node->parent->color;
parent->color = BLACK;
broNode->left->color = BLACK;
rbtree_right_rotate(root, parent);
node = root;
break;
}
}
}
if (node) node->color = BLACK;
}
template<class Type>
void RBTree<Type>::delete_rbtree( Type key)
{
RBTreeNode<Type>* z;
if ((z = search(m_root, key)) != NULL)
rbtree_delete(m_root, z);
else cout << key << "不存在" << endl;
}
template<class Type>
void RBTree<Type>::preOrder(RBTreeNode<Type>* tree) {
if (tree) {
cout << tree->key << " ";
preOrder(tree->left);
preOrder(tree->right);
}
}
template<class Type>
void RBTree<Type>::preOrder_rbtree() {
if (m_root) {
preOrder(m_root);
cout << endl;
}
}
template<class Type>
void RBTree<Type>::InOrder(RBTreeNode<Type>* tree) {
if (tree) {
InOrder(tree->left);
cout << tree->key << " ";
InOrder(tree->right);
}
}
template<class Type>
void RBTree<Type>::InOrder_rbtree() {
if (m_root) {
InOrder(m_root);
cout << endl;
}
}
int main() {
int a[] = { 10, 40, 30, 60, 90, 70, 20, 50, 80 };
RBTree <int> * rbtree=new RBTree<int>();
for(int i=0;i<9;i++)
rbtree->insert_rbtree(a[i]);
rbtree->print_rbtree();
rbtree->preOrder_rbtree();
rbtree->InOrder_rbtree();
cout << "Input an number to be deleted:" << endl;
int key=-1;
cin >> key;
rbtree->delete_rbtree( key);
rbtree->print_rbtree();
cout << "Input an number to be added:" << endl;
cin >> key;
rbtree->insert_rbtree(key);
rbtree->print_rbtree();
}