完整的C++实现算法导论十三章红黑树以及十四章中的顺序统计树

#include<iostream>
using namespace std;
class BRTree;
class BRTreeNode{
private:
	friend class BRTree;
	int key;
	bool  color;
	int size;
	BRTreeNode *left;
	BRTreeNode *right;
	BRTreeNode *parent;
public:
	//创建一个默认构造函数
	BRTreeNode():key(-1),color(0),size(0),left(NULL),right(NULL),parent(NULL){}
	//创建一个拷贝构造函数
	BRTreeNode(BRTreeNode *node):key(node->key),color(node->color),size(node->size),left(node->left),right(node->right),parent(node->parent){}
	//创建一个含有参数的构造函数
	BRTreeNode(int num,int flag,int value):key(num),color(flag),size(value),left(NULL),right(NULL),parent(NULL){}
	//下面创建一个析构函数
	~BRTreeNode()
	{}
	//下面定义一个返回结点值的函数
	int getkey()
	{
		return key;
	}
	//下面定义一个返回标记的函数
	bool getcolor()
	{
		return this->color;
	}
	 BRTreeNode* GetLeft()  
    {  
        return this->left;  
    }  
    BRTreeNode* Getright()  
    {  
        return this->right;  
    }  
    BRTreeNode* Getparent()  
    {  
        return this->parent;  
    } 
	void inorder()
	{
		if(this!=NULL)
		{
			this->left->inorder();
			cout<<"中序遍历的值是"<<this->key<<endl;
			this->right->inorder();
		}
	}
	//下面定义一个前序遍历的函数
	void preorder()
	{
		if(this!=NULL)
		{
			cout<<"前序遍历的结果是"<<this->key<<endl;
			this->left->preorder();
			this->right->preorder();
		}
	}
	//6
	  void Postorder()  
    {  
        if(this!=NULL)  
        {  
            this->left->Postorder();  
            this->right->Postorder();  
            cout<<this->key<<" ";  
        }  
    }
    void make_empty()
	{
		if(this!=NULL)
		{
			this->left->make_empty();
			this->right->make_empty();
			delete this;
		}
	}
	int getheight()
	{
		int L,R;
		if(this==NULL)
		{
			return 0;
		}
		L=this->left->getheight();
		R=this->right->getheight();
		return 1+(L>R)?L:R;
	}


};


class BRTree{
private:
	BRTreeNode *root;
	BRTreeNode *nil;
public:
	BRTree():nil(new BRTreeNode())
	{
		nil->color=0;
		nil->key=-1;
		nil->left=nil->right=nil->parent=NULL;
		root=nil;
	}
	//下面定义一个以清空node为根结点的树
	 void MakeEmpty(BRTreeNode*node)  
    {  
        if(node!=nil)  
        {  
            MakeEmpty(node->left);  
            MakeEmpty(node->right);  
            delete node;  
        }  
    }  
    int Getkey(BRTreeNode* node)  
    {  
		return node->getkey();  
    }  
    bool Getcolor(BRTreeNode* node)  
    {  
		return node->getcolor();  
    }  
    BRTreeNode* Getroot()  
    {  
        return root;  
    }  
    BRTreeNode* GetParent(BRTreeNode*node)  
    {  
        return node->parent;  
    }  
    int GetHeight(BRTreeNode *node)  
    {  
        int L,R;  
        if(node==nil)  
            return 0;  
        L=GetHeight(node->left);  
        R=GetHeight(node->right);  
        return 1+(L>R? L:R);  
    }  
    void Inorder(BRTreeNode *node)  
    {  
        if(node!=nil)  
        {  
            Inorder(node->left);  
            cout<<node->key<<" ";  
            Inorder(node->right);  
        }  
    }  
    void Preorder(BRTreeNode *node)  
    {  
        if(node!=nil)  
        {  
            cout<<node->key<<" ";  
            Preorder(node->left);  
            Preorder(node->right);  
        }  
    }  
    void Posetorder(BRTreeNode*node)  
    {  
        if(node!=nil)  
        {  
            Posetorder(node->left);  
            Posetorder(node->right);  
            cout<<node->key<<" ";  
        }  
    }   
    //左旋节点node  
    bool LeftRotate(BRTreeNode* node)  
    {  
        BRTreeNode *y;  
        if(node->right==nil)  
        {  
            cout<<"can't left rotate!"<<endl;  
            return 0;  
        }  
        y=node->right;  
        node->right=y->left;  
        if(y->left!=nil)  
        {  
            y->left->parent=node;  
        }  
        y->parent=node->parent;  
        if(node->parent==nil)  
        {  
            root=y;  
        }  
        else if(node->parent->left==node)  
        {  
            node->parent->left=y;  
        }  
        else  
        {  
            node->parent->right=y;  
        }  
        y->left=node;  
        node->parent=y;
		//调整size域的大小
		y->size=node->size;
		node->size=node->left->size+node->right->size;
        return 1;  
    }  




	  //下面定义的是一个右旋函数
     bool RightRotate(BRTreeNode* node)  
      {  
        if(node->left==nil)  
        {  
            cout<<"can't rightrotate!"<<endl;  
            return 0;  
        }  
        BRTreeNode* x;  
        x=node->left;  
        node->left=x->right;  
        if(x->right!=nil)  
        {  
            x->right->parent=node;  
        }  
        x->parent=node->parent;  
        if(node->parent==nil)  
        {  
            root=x;  
        }  
        else if(node->parent->left==node)  
        {  
            node->parent->left=x;  
        }  
        else  
        {  
            node->parent->right=x;  
        }  
        node->parent=x;  
        x->right=node;  
		x->size=node->size;
		node->size=node->left->size+node->right->size;
        return 1;  
      }  

	//插入一个值
	 void Insert(int num)  
    {  
        BRTreeNode* node=new BRTreeNode(num,1,1);  
        node->left=nil;  
        node->right=nil;  
        node->parent=nil;  
        BRTreeNode* p=root,*q=nil;  
        if(root==nil)  
        {  
            node->color=0;  
            root=node;  
            root->left=root->right=root->parent=nil;  
			root->size=1;
            return ;  
        }  
        while(p!=nil)  
        {  
            if(p->key==num)  
            {  
                cout<<num<<"  has exist!"<<endl;  
                return ;  
            } 
			
            else if(p->key>num)  
			{   p->size+=1;
				q=p;  
                p=p->left;  
            }  
            else  
            {  p->size+=1;
                q=p;  
                p=p->right;  
            }  
        } 

        if(q->key>num)  
        {  
            q->left=node;  
            node->parent=q;  
        }  
        else  
        {  
            q->right=node;  
            node->parent=q;  
        }  
        RBInsertAdjust(node);  
    }  
	 void RBInsertAdjust(BRTreeNode* node)  
    {  
        BRTreeNode* y;  
        while(node->parent->color==1)  
        {  
            if(node->parent==node->parent->parent->left)  
            {  
                y=node->parent->parent->right;  
                if(y->color==1)  
                {  
                    node->parent->color=0;  
                    y->color=0;  
                    y->parent->color=1;  
                    node=node->parent->parent;  
                }  
                //此时y的颜色是黑色  
                else   
                {  
                    //第二种情况  
                    if(node==node->parent->right)  
                    {  
                        node=node->parent;  
                        LeftRotate(node);  
                    }  
                    //第三种情况  
                    node->parent->color=0;  
                    node->parent->parent->color=1;  
                    RightRotate(node->parent->parent);  
                }     
            }  
            else  
            {  
                y=node->parent->parent->left;  
                if(y->color==1)  
                {  
                    node->parent->color=0;  
                    y->color=0;  
                    y->parent->color=1;  
                    node=node->parent->parent;  
                }  
                else   
                {  
                    if(node==node->parent->left)  
                    {  
                        node=node->parent;  
                        RightRotate(node);  
                    }  
                    node->parent->color=0;  
                    node->parent->parent->color=1;  
                    LeftRotate(node->parent->parent);  
                }  
            }  
        }  
        root->color=0;  
    } 
	 //搜索某个值
	  BRTreeNode* Search(int num)  
    {  
        BRTreeNode* p=root;  
        while(p!=nil)  
        {  
            if(p->key==num)  
            {  
                return p;  
            }  
            else if(p->key>num)  
            {  
                p=p->left;  
            }  
            else   
            {  
                p=p->right;  
            }  
        }  
        cout<<"there is no "<<num<<" in this tree!"<<endl;  
        return nil;  
    }  
    //获取以node节点为根节点的树的最小元素，并返回该最小值 
	  int Minnum(BRTreeNode*node)  
    {  
        BRTreeNode*p=node;  
        while(p->left!=nil)  
        {  
            p=p->left;  
        }  
        return p->key;  
    }  
    //获取以node节点为根节点的树的最da元素，并返回该最da值  
    int Maxnum(BRTreeNode*node)  
    {  
        BRTreeNode*p=node;  
        while(p->right!=nil)  
        {  
            p=p->right;  
        }  
        return p->key;  
    }  
    //获取以node节点为根节点的树的最小元素，并返回该节点  
    BRTreeNode* MinNum(BRTreeNode*node)  
    {  
        BRTreeNode*p=node;  
        while(p->left!=nil)  
        {  
            p=p->left;  
        }  
        return p;  
    }  
    //获取以node节点为根节点的树的最大元素  
    BRTreeNode* MaxNum(BRTreeNode*node)  
    {  
        BRTreeNode*p=node;  
        while(p->right!=nil)  
        {  
            p=p->right;  
        }  
        return p;  
    }  





	 BRTreeNode*InorderSuccessor(BRTreeNode*node)  
    {  
        if(node->right!=nil)  
        {  
            return MinNum(node->right);  
        }  
        else  
        {  
            BRTreeNode*p=GetParent(node);  
            while(p&&node==p->right)  
            {  
                node=p;  
                p=GetParent(node);  
            }  
            return p;  
        }  
    }  
    //中序遍历的前趋  
    BRTreeNode*InordePredecessor(BRTreeNode*node)  
    {  
        if(node->left!=nil)  
        {  
            return MaxNum(node->left);  
        }  
        else  
        {  
            BRTreeNode*p=GetParent(node);  
            while(p&&node==p->left)  
            {  
                node=p;  
                p=GetParent(node);  
            }  
            return p;  
        }     
    }  
    bool Delete(int num)  
    {  
        BRTreeNode*z,*y,*x;    
        //寻找key值为num的节点p    
        z=Search(num);   
        //如果没有该节点则返回0  
        if(z==nil)    
        {    
            return 0;    
        }  
        if(z->left==nil||z->right==nil)  
        {  
            y=z;  
        }  
        else  
            y=InorderSuccessor(z);  
        if(y->left!=nil)  
            x=y->left;  
        else  
            x=y->right;  
        x->parent=y->parent;  
        if(x->parent==nil)  
            root=x;  
        else if(y=y->parent->left)  
            y->parent->left=x;  
        else  
            y->parent->right=x;  
		while(y!=root)
		{
			y->parent->size=y->parent->size-1;
			y=y->parent;
		}
        if(y!=z)  
        {  
            z->key=y->key;  
        }  
        if(y->color==0)  
        {  
            RBTreeFixup(x);  
        }  
        return 1;  
    }  
    void RBTreeFixup(BRTreeNode* x)  
    {  
        BRTreeNode *w;  
        while(x!=root&&x->color==0)  
        {  
            if(x==x->parent->left)  
            {  
                w=x->parent->right;  
                if(w->color==1)  
                {  
                    w->color=0;  
                    x->parent->color=1;  
                    LeftRotate(x->parent);  
                    w=x->parent->right;  
                }  
                if(w->left->color==0&&w->right->color==0)  
                {  
                    w->color=1;  
                    x=x->parent;  
                }  
                else   
                {  
                    if(w->right->color==0)  
                    {  
                        w->color=1;  
                        RightRotate(w);  
                        w=x->parent->right;  
                    }  
                    w->color=x->parent->color;  
                    x->parent->color=0;  
                    w->right->color=0;  
                    LeftRotate(x->parent);  
                    x=root;  
                }  
            }  
            else  
            {  
                w=x->parent->left;  
                if(w->color==1)  
                {  
                    w->color=0;  
                    x->parent->color=1;  
                    RightRotate(x->parent);  
                    w=x->parent->left;  
                }  
                if(w->right->color==0&&w->left->color==0)  
                {  
                    w->color=1;  
                    x=x->parent;  
                }  
                else   
                {  
                    if(w->left->color==0)  
                    {  
                        w->color=1;  
                        LeftRotate(w);  
                        w=x->parent->left;  
                    }  
                    w->color=x->parent->color;  
                    x->parent->color=0;  
                    w->left->color=0;  
                    RightRotate(x->parent);  
                    x=root;  
                }  
            }  
        }  
        x->color=0;  
    }  
	//下面根据统计秩来找出相应的元素，其实也就是中序排列所处的位置

	~BRTree()
	{
		MakeEmpty(root); 
		delete nil;
	}

	BRTreeNode *os_select(BRTreeNode *startnode,int i)
	{
		int r=startnode->size+1;
		if(r==i)
		{
			return startnode;
		}
		else if(i<r)
		{
			return os_select(startnode->left,i);
		}
		else
		{
			return os_select(startnode->right,i-r);
		}
	}
	//下面定义一个给定结点的指针来找出其秩的函数
	int os_rank(BRTreeNode *startnode)
	{
		int r=startnode->left->size+1;
		BRTreeNode *y=startnode;
		while(y!=root)
		{
			if(y==y->parent->right)
			{
				r+=y->parent->left->size+1;
			}
			y=y->parent;
		}
		return r;
	}

};
int main()
{   
	
	BRTree tree;  
    int a[8]={11,2,1,7,5,8,14,15};  
    int i;  
    for(i=0;i<8;i++)  
    {  
        tree.Insert(a[i]);  
    }  
    tree.Inorder(tree.Getroot());  //输出的结果是从小到大输出，其结果是1 2 5 7 8 11 14 15；
    cout<<endl;  
    /*tree.Insert(4);  //插入一个的值是为4的；
    tree.Inorder(tree.Getroot());  //中序输出插入4之后序列的结果为 1 2 4 5 7 8 11 14 15
    cout<<endl;  
    tree.Insert(6);  
    tree.Inorder(tree.Getroot());  
    cout<<endl;  
    tree.Insert(3);  
    tree.Inorder(tree.Getroot());  
    cout<<endl;  
    cout<<tree.GetHeight(tree.Getroot());  
    cout<<endl;  
    tree.Delete(2);  
    tree.Inorder(tree.Getroot());  
    cout<<endl;  */
	tree.Insert(4);
	 tree.Inorder(tree.Getroot());  
	cout<<tree.os_rank(tree.Search(5))<<endl;

	system("pause");
	return 0;
}