红黑树实现

红黑书具体介绍见，里面详细介绍了旋转以及各个情况的处理很详细：

http://blog.csdn.net/v_july_v/article/details/6105630

实现代码：基本上是个伪stl的set，但是加了kth和rank以及lower_bound还有depth等，可以print观察树的构造，但是有些细节的边界取值没处理太好。

#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;

/* 0 => black , 1 => red */

#define black 0
#define red   1
#define right ch[1]
#define left  ch[0]


template<typename T>
class rb_tree{
    /* Note:
     * kth()由于是模版函数当超出值的时候返回faultdata->data，这个方法是在实现的时候需要自己定义错误
     */
private:
    struct node{
        node *ch[2],*pa;//child[2] parent
        int s;//sun
        bool c;//flag
        T data;
        node(const T&d,node*p){
            pa=p;s=1,c=1,data=d;
        }
        node(){
            s=0,c=0;
            ch[0]=ch[1]=pa=this;
        }
        //void setdata(const T&d){data=d;}
    }*nil,*root;
    node *faultdata;
    inline void rotate(node*o,bool d){
        node *father=o->pa;
        if(!father->s){
            root=o->ch[!d];
        }
        else{
            if(o==father->right)
                father->right=o->ch[!d];
            else
                father->left=o->ch[!d];
        }
        o->ch[!d]->pa=o->pa;
        o->pa=o->ch[!d];
        o->ch[!d]=o->pa->ch[d];
        o->pa->ch[d]=o;
        if(o->ch[!d]->s)o->ch[!d]->pa=o;
        o->pa->s=o->s;
        o->s=o->ch[0]->s+o->ch[1]->s+1;
    }
    inline void setdata(node*o,const T&data){
        o->data=data;
    }
    inline node *find(node*o,const T&data){
        while(o->s&&o->data!=data){
            if(o->data<data)o=o->right;
            else            o=o->left;
        }
        if(o->s>0)return o;
        else  return 0;
    }
    /**
     * 插入修复情况1：如果当前结点的父结点是红色且祖父结点的另一个子结点（叔叔结点）是红色
     * 解决策略是：将当前节点的父节点和叔叔节点涂黑，祖父结点涂红，
     * 把当前结点指向祖父节点，从新的当前节点重新开始算法。

     * 插入修复情况2：当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的右子
     * 解决对策是：当前节点的父节点做为新的当前节点，以新当前节点为支点左旋。

     * 插入修复情况3：当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的左子
     * 解决对策是：父节点变为黑色，祖父节点变为红色，在祖父节点为支点右旋。
     *
     */
    inline void insert_fix(node*&o){
        while(o->pa->c==red){//如果父亲节点颜色是red，前提条件
            bool d=o->pa==o->pa->pa->ch[0];//判断祖父左儿子右儿子，1为左儿子，0为右儿子，为的是后面取uncle的时候反用01。
            node *uncle=o->pa->pa->ch[d];//爷爷的另外儿子，父亲兄弟
            if(uncle->c==red){//case1
                uncle->c=o->pa->c=black;//父亲和叔叔都是黑色
                o->pa->pa->c=red;//爷爷为红色
                o=o->pa->pa;
            }else{
                if(o==o->pa->ch[d]){//case2
                    o=o->pa;
                    rotate(o,!d);
                }
                o->pa->c=black; //把父亲的颜色置为黑色
                o->pa->pa->c=red;//祖父为红色
                rotate(o->pa->pa,d);//case3
            }
        }
        root->c=black;//跟节点总为黑色
    }

    /**
     * 删除修复情况1：当前节点是黑+黑且兄弟节点为红色(此时父节点和兄弟节点的子节点分为黑)
     * 解法把父节点染成红色，把兄弟结点染成黑色，之后重新进入算法。
     *
     * 删除修复情况2：当前节点是黑加黑且兄弟是黑色且兄弟节点的两个子节点全为黑色
     * 解法：把当前节点和兄弟节点中抽取一重黑色追加到父节点上，把父节点当成新的当前节点，重新进入算法。
     *
     * 删除修复情况3：当前节点颜色是黑+黑，兄弟节点是黑色，兄弟的左子是红色，右子是黑色
     * 解法：把兄弟结点染红，兄弟左子节点染黑，之后再在兄弟节点为支点解右旋，之后重新进入算法。
     *
     * 删除修复情况4：当前节点颜色是黑-黑色，它的兄弟节点是黑色，但是兄弟节点的右子是红色，兄弟节点左子的颜色任意
     * 解法：把兄弟节点染成当前节点父节点的颜色，把当前节点父节点染成黑色，兄弟节点右子染成黑色，之后以当前节点的父节点为支点进行左旋，此时算法结束，红黑树所有性质调整正确
     *
     **/

    inline void erase_fix(node*&x){
        while(x!=root&& (x->c)==black) //当前节点非root且为黑色
        {
            bool d=x==x->pa->ch[0];
            node *w=x->pa->ch[d];//当前节点的兄弟节点
            if(w->c==red){//case1
                w->c=black;
                x->pa->c=red;
                rotate(x->pa,!d);
                w=x->pa->ch[d];
            }
            if(w->ch[0]->c==black && w->ch[1]->c==black){//case2
                w->c=red;x=x->pa;
            }else{
                if(w->ch[d]->c==black){//case3,4合并
                    w->ch[!d]->c=black;
                    w->c=red;
                    rotate(w,d);
                    w=x->pa->ch[d];
                }
                w->c=x->pa->c;
                w->ch[d]->c=x->pa->c=black;
                rotate(x->pa,!d);
                break;
            }
        }
        x->c=black;
    }
    void clear(node*&o){
        if(o->s){
            clear(o->ch[0]);
            clear(o->ch[1]);
            delete(o);
        }
    }
    inline void dfsprint(node*&x){
        if(x==nil)return;
        cout<<"root:"<<(x->data);
        if(x->ch[0]!=nil)cout<<"   l:"<<(x->ch[0]->data);
        else
            cout<<"  end";
        if(x->ch[1]!=nil)cout<<"   r:"<<(x->ch[1]->data)<<endl;
        else
            cout<<"  end"<<endl;
        dfsprint(x->ch[0]);
        dfsprint(x->ch[1]);
    }
    inline int depthdfs(node *&x)
    {
        if(x==nil)return 0;
        int mx=0;
        mx=max(mx,depthdfs(x->ch[0]));
        mx=max(mx,depthdfs(x->ch[1]));
        return mx+1;
    }
public:
    //构造函数初始化 new 节点
    rb_tree():nil(new node),root(nil),faultdata(new node){}
    ~rb_tree(){clear(root),delete nil;}
    inline void clear(){clear(root),root=nil;}
    inline void insert(const T&data){
        node *o=root;
        if(!o->s){
            root=new node(data,nil);
            root->ch[0]=root->ch[1]=nil;
        }else{
            for(;;){
                o->s++;
                bool d=(o->data)<data;//左0右1
                if(o->ch[d]->s)o=o->ch[d];//儿子还能有儿子
                else{
                    //否则就新建节点
                    o->ch[d]=new node(data,o),o=o->ch[d];
                    o->ch[0]=o->ch[1]=nil;
                    break;
                }
            }
        }
        insert_fix(o);
    }
    inline bool erase(const T&data){
        node *o=find(root,data);
        if(!o)return 0;
        node *t=o,*p;
        if(o->ch[0]->s&&o->ch[1]->s){
            t=o->ch[1];
            while(t->ch[0]->s)t=t->ch[0];
        }
        p=t->ch[!t->ch[0]->s];
        p->pa=t->pa;
        if(!t->pa->s)root=p;
        else t->pa->ch[t->pa->ch[1]==t]=p;
        if(t!=o)o->data=t->data;
        for(o=t->pa;o->s;o=o->pa)o->s--;
        if(!t->c)erase_fix(p);
        delete t;
        return 1;
    }
    inline bool find(const T&data){
        return find(root,data);
    }
    //0开始的排名
    inline int rank(const T&data){
        int cnt=0;
        for(node *o=root;o->s;)
            if(o->data<data)cnt+=o->ch[0]->s+1,o=o->ch[1];
            else o=o->ch[0];
        return cnt;
    }
    //kth由于是模版函数当超出值的时候返回faultdata->data的data，这个方法是错误的，需要给定值
    inline const T&kth(int k){
        for(node *o=root;;)
            if(k<=o->ch[0]->s){
                if(k<0)return faultdata->data;
                o=o->ch[0];
            }
            else if(k==o->ch[0]->s+1)return o->data;
            else {
                k-=o->ch[0]->s+1,o=o->ch[1];
                if(k<0 || o==nil)return faultdata->data;
            }
    }
    inline const T&operator[](int k){
        return kth(k);
    }
    //这里pre并没有做有值判断，所以可能某个值是没有的，那么可以先find一次
    inline const T&preorder(const T&data){
        node *x=root,*y=0;
        while(x->s)
            if(x->data<data){y=x,x=x->ch[1];}
            else{
                x=x->ch[0];
                // 这里key值唯一，那么如果右儿子为空那么就是fault
                if(x==nil)return faultdata->data;
            }
        if(y){
            //   if(y==nil)return faultdata->data;
            return y->data;
        }
        return data;
    }
    //这里pre并没有做有值判断，所以可能某个值是没有的，那么可以先find一次
    inline const T&nextorder(const T&data){
        node *x=root,*y=0;
        while(x->s)
            if(data<x->data)y=x,x=x->ch[0];
            else x=x->ch[1];
        if(y)return y->data;
        return data;
    }
    inline int size(){return root->s;}

    inline void print(){
        dfsprint(root);
    }
    //设置错误的返回值
    inline void setfault(const T&data){
        setdata(faultdata,data);
    }

    inline int depth(){
        return depthdfs(root);
    }
    inline void change(const T&data1,const T&data2){
        erase(data1);
        insert(data2);
    }
    //第一个为第几个数，第二个为值
    inline pair<int,T> lower_bound(const T&data){
        int cnt=0;
        T v=0;
        for(node *o=root;o->s;){
            if(o->data<data){
                cnt+=o->ch[0]->s+1;
                o=o->ch[1];
            }
            else {
                o=o->ch[0];
            }
            if(o!=nil){
                v=o->data;
            }
        }
        return make_pair(cnt,v);
    }
};
int main()
{
    rb_tree<int> a;
    //for(int i=1;i<=4;i++)
    a.insert(1);
    a.insert(2);
    a.insert(4);
    a.insert(5);
    a.setfault(-1);
    //cout<<a[50]<<endl;

    //cout<<a.preorder(2)<<endl;
    //cout<<a.preorder(-2)<<endl;
    //cout<<a.preorder(1)<<endl;
    //cout<<a.nextorder(-1)<<endl;
    //cout<<a.nextorder(101)<<endl;
    //cout<<"find:"<<a.find(40)<<endl;
    //cout<<"rank:"<<a.rank(1)<<endl;
    //cout<<"kth :"<<a.kth(50)<<endl;

    //a.print();
    //cout<<endl<<"dep:"<<a.depth()<<endl;
    //a.change(2,5);
    //a.print();
    pair<int,int> pr=a.lower_bound(6);
    cout<<"pair"<<endl;
    cout<<pr.first<<" "<<pr.second<<endl;
}