红黑树学习--C++编写

//原理参考： https://www.jianshu.com/p/e136ec79235c

//写了红黑树的创建、插入、左右旋。

#define BLACK 1
#define RED 0
#include <iostream>
using namespace std;


//红黑树类
class bst{
private:
    struct Node{
        int value;
        bool color;
        Node *lefttree,*righttree,*parent;

        Node():value(0),color(RED),lefttree(NULL),righttree(NULL),parent(NULL){};

        Node* grandparent(){
            if(parent == NULL)
                return NULL;
            return parent->parent;

        }

        Node* uncle(){
            if(grandparent()==NULL)
                return NULL;
            if(parent == grandparent()->lefttree)
                return grandparent()->righttree;
            else
                return grandparent()->righttree;            
        }

        Node* sibling(){
         //   if(parent != NULL){
                if(this == parent->lefttree)
                    return parent->righttree;
                else 
                    return parent->lefttree;
         //   }
        }


    };

    void right_rotate(Node* p){
        if(p->parent == NULL)
        {
            root = p;
            return ; 
        }
        Node* gt = p->grandparent();
        Node* ft = p->parent;
        Node* y = p->righttree;

        ft->lefttree = y;
        if(y != NIL )
            y->parent = ft;
        
        p->righttree = ft;
        ft->parent = p;
        if(root == ft)
            root = p;        
        p->parent = gt;

        if(gt != NULL){
            if(ft == gt->lefttree)
                gt->lefttree = p;
            else 
                gt->righttree = p;
        }

    }

    void left_rotate(Node* p){
        if(p->parent == NULL)
        {
            root = p;
            return ; 
        }
        Node* gt = p->grandparent();
        Node* ft = p->parent;
        Node* y = p->lefttree;

        ft->righttree = y;
        if(y != NIL )
            y->parent = ft;
        
        p->lefttree = ft;
        ft->parent = p;
        if(root == ft)
            root = p;        
        p->parent = gt;
        
        if(gt != NULL){
            if(ft == gt->lefttree)
                gt->lefttree = p;
            else 
                gt->righttree = p;
        }
    }

void insert(Node *p, int data) {
		if (p->value >= data) {
			if (p->lefttree != NIL)
				insert(p->lefttree, data);
			else {
				Node *tmp = new Node();
				tmp->value = data;
				tmp->lefttree = tmp->righttree = NIL;
				tmp->parent = p;
				p->lefttree = tmp;
				insert_case(tmp);
			}
		}
		else {
			if (p->righttree != NIL)
				insert(p->righttree, data);
			else {
				Node *tmp = new Node();
				tmp->value = data;
				tmp->lefttree = tmp->righttree = NIL;
				tmp->parent = p;
				p->righttree = tmp;
				insert_case(tmp);
			}
		}
	}

    void insert_case(Node* p){
        if(p->parent == NULL){
            root = p;
            p->color = BLACK;
            return ;
        }
        //else{
            if(p->parent->color == RED ) {//插入节点的父节点是红色
                if(p->uncle()->color == RED )  //插入节点的叔叔节点是红色
                { //颜色转换
                    p->grandparent()->color = RED;
                    p->parent->color = p->uncle()->color = BLACK;
                    p->color = RED;
                    // 如果祖父的颜色是红色，要对祖父进一步调节
                    if(p->grandparent()->color == RED)
                        insert_case(p->grandparent());

                }
                else{
                    if(p == p->parent->righttree && p->parent == p->grandparent()->lefttree)
                    {
                        left_rotate(p);
                        right_rotate(p);
                        p->color = BLACK;
                        p->lefttree->color = p->righttree->color = RED;
                    }
                    else   if(p == p->parent->lefttree && p->parent == p->grandparent()->righttree)
                    {
                        right_rotate(p);
                        left_rotate(p);                        
                        p->color = BLACK;
                        p->lefttree->color = p->righttree->color = RED;
                    }
                    else   if(p == p->parent->lefttree && p->parent == p->grandparent()->lefttree)
                    {
                        p->parent->color = BLACK;
                        p->grandparent()->color = RED;
                        left_rotate(p->parent);                        
                    }
                    else   if(p == p->parent->righttree && p->parent == p->grandparent()->righttree)
                    {
                        p->parent->color = BLACK;
                        p->grandparent()->color = RED;
                        right_rotate(p->parent);  
                    }
                }
            }
        //}
    }

    void delete_tree(Node* p){

    }

    void inorder(Node* p){
        if(p == NIL)    return ;
        if(p->lefttree)
            inorder(p->lefttree);
        
        cout<<p->value<<" ";
        if(p->righttree)
            inorder(p->righttree);       
    }
public:
    bst(){
        
        NIL = new Node();
        NIL->color = BLACK;
        root = NULL;
    }



    void insert(int x){
        if(root==NULL){
            root  = new Node();//新建
            root->color = BLACK;            
            root->lefttree = root->righttree = NIL;
            root->value = x;
        }
        else{
            insert(root,x);
        }
    }

    void inorder(){
        if(root == NULL)
            return ;
        inorder(root);
        cout<<endl;
    }

private:
    Node *root,*NIL;
};

int main()
{
    bst tree;

	// 插入元素
	tree.insert(2);
	tree.insert(9);
	tree.insert(-10);
	tree.insert(0);
	tree.insert(33);
	tree.insert(-19);

	// 顺序打印红黑树
	cout << "inserted : ----" << endl;
	tree.inorder();

    system("pause");
    return 0;
}