算法导论 第13章 红黑树

为了让这片博客看起来更有营养一些，我还是在添加一些红黑树的设计原理吧？

Q:为什么要为叶节点加入终止节点NIL？

A:其实这个NIL的假如本省没有什么，但是当规定完NIL的颜色为Black时，他的作用就显现出来了，但他的颜色为Black时无论是Insert还是delete，都可以起到辅佐判断的作用例：

假如向上面这种情况，插入节点为C那么我们就可以通过判断其叔节点的颜色，也就是NIL的颜色把其对应于正确的case2中去。

不知道是我买的是盗版的原因还是本身书中就有这个问题《算法导论》中文翻译第三版的179页的关于RB-INSERT-FLXUP的操作中对于case3没有加else，这应该是错误的，应该是在case2后加上case3，然后再加上在else里写上case3。

下面是算法导论红黑树部分的代码实现，其中大部分代码是根据算法导论的二叉树的部分改编过来的，所以会看到一些有些过于单纯的二叉树操作还请见谅！

重点强调了红黑树的插入和删除部分的代码！！

这个代码还是写了不少的，但是为什么会有红黑树这种数据结构，换句话说通过导论引理13.1的证明，这中操作后能保证搜索二叉树的高度小于lg(n+1)，但如果仅从这个角度产生的对于搜索的代价来看的话红黑树的优势显然不如AVL，那么为什么要用红黑树呢？

代码：

#include<iostream>
#include<stack>

using namespace std;

#define Red 1
#define Black 0

typedef struct node
{
    int key;
    node* left;
    node* right;
    node* parent;
    int color;    //    红黑树的节点颜色标识,选取Red-1，Black-0;
}Node;

int visited;
int colorFlag;
Node* NIL;
Node* Root;

//    创建二叉树，数据来控制台。按中序遍历的方式输入。
void CreatBinaryTree(Node &node)
{
    cout << "输入" << node.key << "的左儿子" << endl;
    int x;
    cin >> x;
    if (x != -1)
    {
        Node *lnode = new Node();
        lnode->key = x;
        node.left = lnode;
        lnode->parent = &node;
        CreatBinaryTree(*lnode);
    }
    else
    {
        node.left = NULL;
    }
    cout << "输入" << node.key << "的右儿子" << endl;
    int y;
    cin >> y;
    if (y != -1)
    {
        Node *rnode = new Node();
        rnode->key = y;
        node.right = rnode;
        rnode->parent = &node;
        CreatBinaryTree(*rnode);
    }
    else
    {
        node.right = NULL;
    }
}

// 按照中序访问建立二叉树，数组要求为先序遍历返回结果，且左儿子，右儿子为空设定起等于-1；
void CreateBinaryTreeByArray(Node *root, int a[])
{
    //输入root的key
    root->key = a[visited];
    visited++;
    if (a[visited] == -1)
    {
        root->left = NULL;
        visited++;
    }
    else
    {
        root->left = new Node();
        root->left->parent = root;
        CreateBinaryTreeByArray(root->left, a);
    }
    if (a[visited] == -1)
    {
        root->right = NULL;
        visited++;
    }
    else
    {
        root->right = new Node();
        root->right->parent = root;
        CreateBinaryTreeByArray(root->right, a);
    }
}

//    递归法中序访问二叉树
void Traverse(Node *root)
{
    if (root != NULL)
    {
        Traverse(root->left);
        cout << root->key << "    " << endl;
        Traverse(root->right);
    }
}


//    非递归借用栈迭代中序遍历二叉树。
void NonRecursionTraverse(Node *root)
{
    stack<Node*> treeStack;
    Node *p = root->left;
    treeStack.push(root);
    while (!(treeStack.empty() && p == NULL))
    {
        while (p != NULL)
        {
            treeStack.push(p);
            p = p->left;
        }
        Node *top = treeStack.top();
        cout << top->key << "    ";
        treeStack.pop();
        p = top->right;
    }
}


//    递归二叉树搜索树的搜索
Node* TreeSearch(Node *root, int x)
{
    if (root == NULL || x == root->key)
        return root;
    if (x < root->key)
        return TreeSearch(root->left, x);
    else
        return TreeSearch(root->right, x);
}


//    非递归二叉搜索树的搜索
Node* InteractiveTreeSearch(Node* root, int x)
{
    while (root != NULL && root->key != x)
    {
        if (x < root->key)
            root = root->left;
        else
            root = root->right;
    }
    return root;
}


//    返回二叉搜索树中关键字最小的元素
Node *TreeMinimum(Node* root)
{
    while (root->left != NULL)
        root = root->left;
    return root;
}

Node* RecursionTreeMinimun(Node* root)
{
    if (root->left == NULL)
        return root;
    return RecursionTreeMinimun(root->left);
}

//    返回二叉搜索树中关键字最大的元素
Node *TreeMaxmum(Node* root)
{
    while (root->right != NULL)
        root = root->right;
    return root;
}


//    返回指定节点的后继（后继的定义见算法导论）
Node *TreeSuccessor(Node *root)
{
    if (root->right != NULL)
        return TreeMinimum(root->right);
    Node* tempParent = root->parent;
    while (tempParent != NULL&&tempParent->left != root)
    {
        root = tempParent;
        tempParent = tempParent->parent;
    }
    return tempParent;
}

//    为一颗红黑树节点设置颜色值；
 
void SetNodeColor(Node * root)
{
    if (root != NIL)
    {
        cout << root->key << "颜色" << endl;
        cin >> root->color;
        SetNodeColor(root->left);
        SetNodeColor(root->right);
    }
}

// 按照中序访问建立红黑树但不涉及节点的颜色
void CreateRBTreeByArray(Node *root, int a[])
{
    //输入root的key
    root->key = a[visited];
    visited++;
    if (a[visited] == -1)
    {
        root->left = NIL;
        visited++;
    }
    else
    {
        root->left = new Node();
        root->left->parent = root;
        CreateRBTreeByArray(root->left, a);
    }
    if (a[visited] == -1)
    {
        root->right = NIL;
        visited++;
    }
    else
    {
        root->right = new Node();
        root->right->parent = root;
        CreateRBTreeByArray(root->right, a);
    }
}
//    遍历一颗红黑树
void TraverseRBTree(Node *root)
{
    if (root != NIL)
    {
        TraverseRBTree(root->left);
        cout << root->key << "颜色：";
        if (root->color == 1)
            cout << "Red" << endl;
        else
            cout << "Black" << endl;
        TraverseRBTree(root->right);
    }
}

void SetRBTreeColorByArray(Node *root, int a[])
{
    if (root != NIL)
    {
        SetRBTreeColorByArray(root->left, a);
        root->color = a[colorFlag];
        colorFlag++;
        SetRBTreeColorByArray(root->right, a);
    }
}

//    作为普通二叉树的插入操作，但仍需要进一步调整
void RBInsert(Node *root, Node *z)
{
    Node* x = root;
    Node* y = x->parent;
    while (x != NIL)
    {
        y = x;
        if (z->key < x->key)
        {
            x = x->left;
        }
        else
        {
            x = x->right;
        }
    }
    z->parent = y;
    if (z->key < y->key)
        y->left = z;
    else
        y->right = z;
    z->left = NIL;
    z->right = NIL;
    z->color = Red;
}

void LeftRotate(Node* root, Node *x)
{
    Node *y = x->right;
    x->right = y->left;
    if (y->left != NIL)
        y->left->parent = x;
    y->parent = x->parent;
    if (x->parent == NIL)
        Root = y;
    if (x == x->parent->left)
        x->parent->left = y;
    else
        x->parent->right = y;
    y->left = x;
    x->parent = y;
}

void RightRotate(Node *root, Node *y)
{
    Node *x = y->left;
    y->left = x->right;
    if (x->right!=NIL)
        y->left->parent = x;
    x->parent = y->parent;
    if (x->parent == NIL)
        Root = x;
    if (y == y->parent->left)
        y->parent->left = x;
    else
        y->parent->right = x;
    x->right = y;
    y->parent = x;
}

void RBFixup(Node *root, Node *z)
{
    while (z->parent->color == Red)
    {
        if (z->parent == z->parent->parent->left)
        {
            Node *y = z->parent->parent->right;
            if (y->color == Red)
            {
                y->color = Black;
                z->parent->color = Black;
                y->parent->color = Red;
                z = y->parent;
            }
            else if (z == z->parent->right)
            {
                z = z->parent;
                LeftRotate(Root, z);

                z->parent->color = Black;
                z->parent->parent->color = Red;
                RightRotate(Root, z->parent->parent);
            }
            else
            {
                z->parent->color = Black;
                z->parent->color = Red;
                RightRotate(root, z->parent->parent);
            }
        }
        else
        {

        }
    }
    Root->color = Black;
}

int main()
{
    //    建立NIL
    NIL = new Node();
    NIL->key = -1;    //    规定NIL的key等于-1；

    int a[] = {11, 2, 1, -1, -1, 7, 5, -1, -1, 8, -1, -1, 14, -1, 15, -1, -1 };
    int color[] = { Black, Red, Red, Black, Red, Black, Black, Red};
    Node *treeroot = new Node();
    treeroot->key = 15;
    treeroot->parent = NIL;
    Root = treeroot;
    visited = 0;
    colorFlag = 0;
    CreateRBTreeByArray(treeroot, a);
    /*SetNodeColor(treeroot);*/
    SetRBTreeColorByArray(treeroot, color);
    TraverseRBTree(treeroot);
    Node* Insert = new Node();
    Insert->key = 6;
    RBInsert(treeroot, Insert);
    cout << TreeSearch(Root, 11)->color << endl;
    RBFixup(treeroot, Insert);
    cout << TreeSearch(Root, 11)->color << endl;
    TraverseRBTree(Root);
    cout << TreeSearch(Root, 11)->color << endl;
    return 0;
}