C++红黑树实现

参考算法导论，STL源码解析，终于把程序调通了。

删除部分还是有点迷糊，下次自己还要钻研钻研！

经过这次调试，发现了好多很小的语法错误会让整个程序工作异常；

#ifndef RBTREE_H
#define RBTREE_H
#include<iostream>
using namespace std;
typedef int DataType;
enum color
{
RED,BLACK
};
typedef struct RBTreeNode
{
DataType key;
int color;
struct RBTreeNode *parent, *left, *right;
RBTreeNode(){}
RBTreeNode(int k) :key(k){  // 创建新结点默认颜色为红色  
color = RED;
parent =NULL;
left = NULL;
right = NULL;
}
const RBTreeNode* operator=(RBTreeNode * c)
{
this->color = c->color;
this->key = c->key;
this->left = c->left;
this->right = c->right;
this->parent = c->parent;
return this;
}
} RBTreeNode;


class RBTree
{
private:
RBTreeNode * Root;
RBTreeNode * Tail;
public:
RBTree(){ Root = NULL; Tail = NULL; }
~RBTree();
void RBTree_init_leaf();
void Insert(DataType d);
void MidOrderShow(RBTreeNode * N);
RBTreeNode *  GetRoot(){ return Root; }
void Delete(RBTreeNode * D);
RBTreeNode * Find(DataType d);
private:
void RB_Transplant(RBTreeNode * u, RBTreeNode * v);//用子树v代替子树u
void Delete_Node(RBTreeNode * N);
void RBTree_Insert_Fixup(RBTreeNode * T);
void Right_Rotate(RBTreeNode * T);
void Left_Rotate(RBTreeNode * T);
RBTreeNode * Tree_Min(RBTreeNode * m);//传入引用出错？？？？
void RB_Delete_Fixup(RBTreeNode * m);
};
void RBTree::Left_Rotate(RBTreeNode * T)
{
RBTreeNode * y;
  RBTreeNode * p=new RBTreeNode;
  p = T->parent;
y = T->right;
T->right = y->left;//把y的左子树给T做右子树
if (y->left != Tail)
y->left->parent = T;

if (T->parent == Tail)
Root=y ;
else
{
if (T == T->parent->left)
T->parent->left = y;
else
T->parent->right = y;
}
    y->parent = p;
T->parent = y;
y->left = T;
}


void RBTree::Right_Rotate(RBTreeNode * T)
{
RBTreeNode * y;
RBTreeNode * p =new RBTreeNode;
p = T->parent;
y = T->left;
T->left = y->right;//把y的左子树给T做右子树
if (y->right != Tail)
y->right->parent = T;

if (T->parent == Tail)
Root = y;
else
{
if (T == T->parent->left)
T->parent->left = y;
else
T->parent->right = y;
}
y->parent = p;
T->parent = y;
y->right = T;

}


void RBTree::RBTree_Insert_Fixup(RBTreeNode * T)
{
RBTreeNode * y,* x;
//r = T;
while (RED == T->parent->color)
{
if (T->parent == T->parent->parent->left)//父为左子树
{
y = T->parent->parent->right;
if (RED == y->color)//case1: 父红叔红（父为左子树）
{
T->parent->color = BLACK;
y->color = BLACK;
T->parent->parent->color = RED;
T = T->parent->parent;
}
else                   
{
if (T == T->parent->right)  //case2: 父红叔黑T为右子树（父为左子树）
{
Left_Rotate(T->parent);
T = T->left;
}
else                       //case3: 父红叔黑T为左子树（父为左子树）
{
T->parent->color = BLACK;
T->parent->parent->color = RED;
Right_Rotate(T->parent->parent);
}
}
}
else                     //父为右子树
{
x = T->parent->parent->left;
if (RED == x->color)        //case4: 父红叔红 （父为右子树）
{
T->parent->color = BLACK;
x->color = BLACK;
T->parent->parent->color = RED;
T = T->parent->parent;
}
else
{
if (T == T->parent->right)//case5: 父红叔黑T为右子树（父为右子树）
{
T->parent->color = BLACK;
T->parent->parent->color = RED;
Left_Rotate(T->parent->parent);
}
else                   //case6: 父红叔黑T为左子树（父为右子树）
{
Right_Rotate(T->parent);
T = T->right;
}
}
}
}
Root->color = BLACK;
}


void RBTree::MidOrderShow(RBTreeNode * N)
{
if (N != Tail)
{
MidOrderShow(N->left);
cout << N->key <<", "<<N->color<< "\t";
MidOrderShow(N->right);
}
}


void RBTree::Insert(DataType d)
{
RBTreeNode* T = new RBTreeNode;
T->key = d;
T->left = T->right = Tail;
T->color = RED;
RBTreeNode* y = new RBTreeNode;
RBTreeNode* x = new RBTreeNode;
y = Root;
x = Tail;
while (y != Tail)
{
x = y;
if (y->key > d)
y = y->left;
else y = y->right;
}
T->parent = x;
if (x == Tail)
{
Root = T; Root->color = BLACK; Root->parent = Tail;
}
else
{
if (x->key > d)
x->left = T;
else
x->right = T;

}
RBTree_Insert_Fixup(T);
}


void RBTree::Delete_Node(RBTreeNode * N)
{
if (N != Tail)
{
//Delete_Node(N->left);
//Delete_Node(N->right);
delete N;
}
}


RBTree::~RBTree()
{
Delete_Node(Root);
delete Tail;
Root = Tail = NULL;
cout << "\nThe RBTree is empty\n";
}


void RBTree::RBTree_init_leaf()
{
Root = new RBTreeNode(-1);
Tail = new RBTreeNode(-99);
Tail->color = BLACK;
Tail->left = NULL;
Tail->right = NULL;
Tail->parent = NULL;
Root = Tail;
Root->parent = Tail;
}


void RBTree::Delete(RBTreeNode * D)
{
RBTreeNode * y,* x;
y = D;
int  original_y_color = y->color;
if (Tail == D->left)//case1: 删除节点的左子树为空
{
x = D->right;
RB_Transplant(D, D->right);
}
else
{
if (Tail == D->right)//case2: 删除节点的右子树为空
{
x = D->left;
RB_Transplant(D, D->left);
}
else                 //删除节点的左右子树都不为空
{
y = Tree_Min(D->right);//删除节点的右子树最小的节点
original_y_color = y->color;
x = y->right;
if (y->parent == D)// case3: 删除节点的右子树的最小节点为删除点的孩子
{
x->parent = y;
}
else               //case3: 删除节点的右子树的最小节点不是删除点的孩子
{
RB_Transplant(y, y->right);
y->right = D->right;
y->right->parent = y;
}
RB_Transplant(D, y);
y->left = D->left;
y->left->parent = y;
y->color = D->color;
}
}
if (BLACK == original_y_color)
RB_Delete_Fixup(x);
}


RBTreeNode * RBTree::Find(DataType d)
{
RBTreeNode * m;
m = Root;
while(m!=Tail&&m->key != d) 
{
if (m->key > d)
m = m->left;
else
m = m->right;
}
if (m == Tail) return Tail;
else return m;
}


void RBTree::RB_Transplant(RBTreeNode * u, RBTreeNode * v)
{
if (u->parent == Tail)
Root = v;
else
{
if (u == u->parent->left)
u->parent->left = v;
else
u->parent->right = v;
}
v->parent = u->parent;
}


RBTreeNode * RBTree::Tree_Min(RBTreeNode * m)
{
RBTreeNode * t;
t = m;
while (Tail != m)
{
t = m;
m = m->left;
}

return t;
}


void RBTree::RB_Delete_Fixup(RBTreeNode * x)
{
RBTreeNode * w;
while (Root != x&&BLACK == x->color)
{
if (x->parent->left == x)//x为左孩子
{
w = x->parent->right;
if (RED == w->color)//case1: x为左孩子兄弟颜色为红
{
w->color = BLACK;
x->parent->color = RED;
Left_Rotate(x->parent);
w = x->parent->right;
}
if (BLACK == w->left->color&&BLACK == w->right->color)//case 2: x为左孩子兄弟的左右孩子的颜色都为黑
{
w->color = RED;
x = x->parent;
}
else
{
if (BLACK == w->right->color)//case 3: x为左孩子兄弟的右孩子的颜色为黑，左孩子为红
{
w->left->color = BLACK;
w->color = RED;
Right_Rotate(w);
w = x->parent->right;
}
else                         //case 4: x为左孩子兄弟的右孩子的颜色为红
{
w->color = x->parent->color;
x->parent->color = BLACK;
w->right->color = BLACK;
Left_Rotate(x->parent);
x = Root;
}
}
}
else                   //x为右孩子
{
w = x->parent->left;
if (RED == w->color)//case5: x为右孩子兄弟颜色为红
{
w->color = BLACK;
x->parent->color = RED;
Right_Rotate(x->parent);
w = x->parent->left;
}
if (BLACK == w->left->color&&BLACK == w->right->color)//case 6: x为右孩子兄弟的左右孩子的颜色都为黑
{
w->color = RED;
x = x->parent;
}
else
{
if (BLACK == w->left->color)//case 7: x为右孩子兄弟的右孩子的颜色为黑
{
w->right->color = BLACK;
w->color = RED;
Left_Rotate(w);
w = x->parent->left;
}
else                         //case 8: x为右孩子兄弟的右孩子的颜色不为黑
{
w->color = x->parent->color;
x->parent->color = BLACK;
w->left->color = BLACK;
Right_Rotate(x->parent);
x = Root;
}
}
}
}
x->color = BLACK;
}


#endif

#include<iostream>
#include"RBTree.h"
using namespace std;


int main()
{
int D[] = { 18, 1, 25, 6, 9, 15, 10 ,26,13,16,5,20};
RBTree M;
M.RBTree_init_leaf();
for (int i = 0; i < 12; ++i)
M.Insert(D[i]);
M.MidOrderShow(M.GetRoot());


RBTreeNode * t = M.Find(15);
cout <<"\n"<< t->key << endl;


M.Delete(M.Find(25));
M.MidOrderShow(M.GetRoot());


return 0;
}