红黑树的插入

一、算法的分析
Step1：将A结点按BST树规则插入红黑树中，Z是叶子节点；
Step2：将Z涂红；
Step3：调整使其满足红黑树的性质；
BRTnsert算法
RBInsert(T, z)
{     y ← nil[T]; //y用于记录：当前扫描节点的双亲节点
    x ← root[T]; //从根开始扫描
    while x ≠ nil[T] do //查找插入位置
    {
        y ← x;
        if key[z] ＜ key[x] then //z插入x的左边
            x ← left[x];
        else
            x ← right[x]; //z插入x的右边
    }
    p[z] ← y; //y是z的双亲
    if y = nil[T] then //z插入空树
        root[T] ← z; //z是根
    else
        if key[z] ＜ key[y] then
            left[y] ← z; //z是y的左子插入
        else
            right[y] ← z; //z是y的右子插入
    left[z] ← right[z] ← nil[T];
    color[z] ← red;
    RBInsertFixup(T, z);
}
时间：T(n)=O(logn)

RBTnsertFixup调整算法
RBInsertFixup(T, z)
{     while ( color[p[z]]=red ) do
    {     //若z为根，则p[z]=nil[T]，其颜色为黑，不进入此循环
        //若p[z]为黑，无需调整，不进入此循环
        if p[z]=left[p[p[z]]] then //case 1,2,3
        {     y ← right[p[p[z]]]; //y是z的叔叔
            if color[y]=red then //case 1
            {     color[y]=black; color[p[z]]=black;
                color[p[p[z]]]=red; z ← p[p[z]];
            }
            else //case 2 or case 3 y为黑
            else //case 2 or case 3 y为黑
            {     
                if z=right[p[z]] then //case 2
                {
                    z ← p[z]; //上溯至双亲
                    leftRotate(T, z);
                }//以下为case 3
                color[p[z]]=black; color[p[p[z]]]=red;
                RightRotate(T, p[p[z]]); //p[z]为黑，退出循环
            } //case 1’s endif
        } //case 2 or 3’ s
        else //case 4,5,6’s 与上面对称
            { … … }
    } //endwhile
    color[root[t]] ← black;
}

算法C代码：
struct BR_NODE* BT_insert_fixup(struct BR_NODE *T, struct BR_NODE *z)
{
    struct BR_NODE *y;
    while (z->parent->color == RED) {
        if (z->parent == z->parent->parent->left) {
            y = z->parent->parent->right;
            if (y->color == RED)    {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else {
                if (z == z->parent->right) {
                    z= z->parent;
                    T = LEFT_ROTATE(T,z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                T = RIGHT_ROTATE(T,z->parent->parent);
            }
        }
        else {//with right and left exchange
            y = z->parent->parent->left;
            if (y->color == RED)    {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else {
                if (z == z->parent->left) {
                    z= z->parent;
                    T = RIGHT_ROTATE(T,z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                T = LEFT_ROTATE(T,z->parent->parent);
            }    
        }
    }
    T->color = BLACK;
    return T;
}

struct BR_NODE* BT_insert(struct BR_NODE *T, int k)
{
    struct BR_NODE *y = T->parent;
    struct BR_NODE *x = T;
    struct BR_NODE *z;
    z= (struct BR_NODE *)malloc(sizeof(struct BR_NODE));
    z->key = k;
    while (x->key != T_nil) {
        y = x;
        if (k< x->key)
            x = x->left;
        else
            x = x->right;
    }
    z->parent = y;
    if (y->key == T_nil)
        T = z;
    else if (z->key <y->key)
        y->left = z;
    else
        y->right =z;
    z->left = T->parent;
    z->right = T->parent;
    z->color = RED;
    return BT_insert_fixup(T,z);
}

二、代码

#include <stdlib.h>
#include <stdio.h>
#include<time.h>
#define T_nil -1
//T_nil is a key of nil[T] in the book.
#define RED      1//
#define BLACK    0//The color of Node


struct BR_NODE {
    int color;
    int key; //
    struct BR_NODE *left;
    struct BR_NODE *right;
    struct BR_NODE *parent;
};

/*output red-black tree in */
int PRINT_NODE(struct BR_NODE *T)
{
    if (T->key != T_nil) {
        PRINT_NODE(T->left);
        printf("%d, %s\n",T->key,(T->color?"RED":"BLACK"));
        PRINT_NODE(T->right);
    }
    return 1;
}

//left totate
struct BR_NODE * LEFT_ROTATE(struct BR_NODE *T, struct BR_NODE *x) 
{
    struct BR_NODE *y;
    y = x->right;
    x->right = y->left;
    if (y->left->key != T_nil)
        y->left->parent = x;
    y->parent = x->parent;
    if    (x->parent->key == T_nil)
        T = y;
    else if (x == x->parent->left)
        x->parent->left = y;
    else
        x->parent->right = y;
    y->left = x;
    x->parent = y;
    return T;
}

//right rotate
struct BR_NODE *RIGHT_ROTATE(struct BR_NODE *T, struct BR_NODE *x)
{
    struct BR_NODE *y;
    y = x->left;
    x->left = y->right;
    if (y->right->key)
        y->right->parent = x;
    y->parent = x->parent;
    if (x->parent->key == T_nil)
        T = y;
    else if (x == x->parent->left)
        x->parent->left = y;
    else
        x->parent->right = y;
    y->right = x;
    x->parent = y;
    return T;
}

struct BR_NODE* BT_insert_fixup(struct BR_NODE *T, struct BR_NODE *z)
{
    struct BR_NODE *y;
    while (z->parent->color == RED) {
        if (z->parent == z->parent->parent->left) {
            y = z->parent->parent->right;
            if (y->color == RED)    {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else {
                if (z == z->parent->right) {
                    z= z->parent;
                    T = LEFT_ROTATE(T,z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                T = RIGHT_ROTATE(T,z->parent->parent);
            }
        }
        else {//with right and left exchange
            y = z->parent->parent->left;
            if (y->color == RED)    {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
            else { 
                if (z == z->parent->left) {
                    z= z->parent;
                    T = RIGHT_ROTATE(T,z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                T = LEFT_ROTATE(T,z->parent->parent);
            }    
        }
    }
    T->color = BLACK;
    return T;
}

struct BR_NODE* BT_insert(struct BR_NODE *T, int k)
{
    struct BR_NODE *y = T->parent;
    struct BR_NODE *x = T;
    struct BR_NODE *z;
    z= (struct BR_NODE *)malloc(sizeof(struct BR_NODE));
    z->key = k;
    while (x->key != T_nil) {
        y = x;
        if (k< x->key)
            x = x->left;
        else
            x = x->right;
    }
    z->parent = y;
    if (y->key == T_nil)
        T = z;
    else if (z->key <y->key)
        y->left = z;
    else
        y->right =z;
    z->left = T->parent;
    z->right = T->parent;
    z->color = RED;
    return BT_insert_fixup(T,z);
}

int main () {
    struct BR_NODE *p,*T;
    struct BR_NODE BRT_nil = {BLACK,T_nil,&BRT_nil,&BRT_nil,&BRT_nil};
    T = &BRT_nil;
    int BRT[10] = {0};//storage the num which need to insert to red-black tree

    printf("需要插入红黑树的节点");
    srand((unsigned)time(NULL));
    for(int i = 0; i <10; i++)
    {
        BRT[i] = rand()%20;//
        printf("%4d", BRT[i]);
    }
    printf("\n");    
    for(int i = 0; i < 10; i++)
    {        
        T=BT_insert(T,BRT[i]);
    }
    PRINT_NODE(T);//output red-black tree
    system("pause");
    return 1;
}