红黑树的C语言实现

最新推荐文章于 2024-07-22 17:11:23 发布
最新推荐文章于 2024-07-22 17:11:23 发布
阅读量441 收藏 1
点赞数
分类专栏： 数据结构 C码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010842019/article/details/79230424
版权

https://tool.lu/coderunner/ 【在线C语言编译】

// 红黑树的C语言实现
#include <stdio.h>
#include <stdlib.h>
const int RED = 0;
const int BLACK = 1;

//---编译条件严格，自己引用自己 需要额外定义一个数据类型 使用typedef关键字
/*  https://tool.lu/coderunner/
该部分有些编译器会报错，如https://tool.lu/coderunner/ 不识别rb_node ， 
    自己引用自己导致 所以需要特殊处理 
   1.声明一个结构体rb_node_p 
   2.指定该结构体类型为rb_node，
   3.定义rb_node_p结构体
   4.在rb_node_p结构体中使用类型  rb_node

struct rb_node_p;  //1
typedef struct rb_node_p rb_node;  //2

struct rb_node_p{   //3
    rb_node* lchild, *rchild, *parent;  //4
    int key, colour;
};

//------------------------
//http://www.runoob.com/try/runcode.php?filename=helloworld&type=c
struct rb_node{
    rb_node* lchild, *rchild, *parent;
    int key, colour;
};*/
//------------------------

struct rb_node_p;  //1
typedef struct rb_node_p rb_node;  //2

struct rb_node_p{   //3
    rb_node* lchild, *rchild, *parent;  //4
    int key, colour;
};



rb_node* root;

rb_node* get_node( rb_node* parent, int key);
void rb_insert(int key);
rb_node* rb_search(int key);
void rb_delete(int key);
rb_node* clock_wise( rb_node* node);
rb_node* counter_clock_wise( rb_node* node);
void show_rb_tree( rb_node* node);

rb_node* get_node( rb_node* parent, int key){
    rb_node *tmp = (rb_node*)malloc(sizeof(rb_node));
    tmp->key = key;
    tmp->colour = RED;
    tmp->parent = parent;
    tmp->lchild = tmp->rchild = NULL;
    return tmp;
}

rb_node* clock_wise(rb_node* node){
    if(node == NULL || node->lchild == NULL)
        return NULL;

    rb_node *rb_1=node, *rb_2=node->lchild, *rb_3=node->lchild->rchild;
    if(rb_1->parent != NULL){
        if(rb_1->parent->lchild == rb_1)
            rb_1->parent->lchild = rb_2;
        else
            rb_1->parent->rchild = rb_2;
    }else if(rb_1 == root){
        root = rb_2;
    }
    rb_2->parent = rb_1->parent;

    rb_1->parent = rb_2;
    rb_2->rchild = rb_1;

    rb_1->lchild = rb_3;
    if(rb_3 != NULL)rb_3->parent = rb_1;

    return rb_2;    
}

rb_node* counter_clock_wise(rb_node* node){
    if(node == NULL || node->rchild == NULL)
        return NULL;

    rb_node *rb_1=node, *rb_2=node->rchild, *rb_3=node->rchild->lchild;
    if(rb_1->parent != NULL){
        if(rb_1->parent->lchild == rb_1)
            rb_1->parent->lchild = rb_2;
        else 
            rb_1->parent->rchild = rb_2;
    }
    else if(rb_1 == root){
        root = rb_2;
    }
    rb_2->parent = rb_1->parent;

    rb_1->parent = rb_2;
    rb_2->lchild = rb_1;

    rb_1->rchild = rb_3;
    if(rb_3 != NULL)rb_3->parent = rb_1;

    return rb_2;
}

rb_node* rb_search(int key){
    rb_node *p = root;
    while(p != NULL){
        if(key < p->key)
            p = p->lchild;
        else if(key > p->key)
            p = p->rchild;
        else
            break;
    }
    return p;
}

void rb_insert(int key){
    rb_node *p=root, *q=NULL;

    if(root == NULL){
        root = get_node(NULL, key);
        root->colour = BLACK;
        return;
    }

    while(p != NULL){
        q = p;
        if(key < p->key)
            p = p->lchild;
        else if(key > p->key)
            p = p->rchild;
        else return;
    }

    if(key < q->key)
        q->lchild = get_node(q, key);
    else
        q->rchild = get_node(q, key);

    while(q != NULL && q->colour == RED){
        p = q->parent;//p won't null, or BUG.

        if(p->lchild == q){
            if(q->rchild != NULL && q->rchild->colour == RED)
                counter_clock_wise(q);        
            q = clock_wise(p);
            q->lchild->colour = BLACK;
        }
        else{
            if(q->lchild != NULL && q->lchild->colour == RED)
                clock_wise(q);
            q = counter_clock_wise(p);
            q->rchild->colour = BLACK;
        }

        q = q->parent;
    }
    root->colour = BLACK;
}

void show_rb_tree(rb_node* node){
    if(node == NULL)
        return;
    if(node->colour == 0){
        if(node->lchild != NULL && node->rchild != NULL){
            if(node->lchild->colour == 0 && node->rchild->colour == 0){
                printf("(|红结点:%d|——|红左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
            if(node->lchild->colour == 0 && node->rchild->colour == 1){
                printf("(|红结点:%d|——|红左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|红结点:%d|——|黑左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 1){
                printf("(|红结点:%d|——|黑左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
        } else if(node->lchild != NULL && node->rchild == NULL ){

            if(node->lchild->colour == 0 ){
                printf("(|红结点:%d|——|红左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }


            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|红结点:%d|——|黑左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }

        } else if(node->lchild == NULL && node->rchild != NULL ){

            if(node->rchild->colour == 0 ){
                printf("(|红结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }


            if(node->rchild->colour == 1 ){
                printf("(|红结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }

        } else {
            printf("(|红结点:%d|——|左空|——|右空|)\n", node->key);
        }
    }
    if(node->colour == 1){
        if(node->lchild != NULL && node->rchild != NULL){
            if(node->lchild->colour == 0 && node->rchild->colour == 0){
                printf("(|黑结点:%d|——|红左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
            if(node->lchild->colour == 0 && node->rchild->colour == 1){
                printf("(|黑结点:%d|——|红左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|黑结点:%d|——|黑左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 1){
                printf("(|黑结点:%d|——|黑左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
        } else if(node->lchild != NULL && node->rchild == NULL ){

            if(node->lchild->colour == 0 ){
                printf("(|黑结点:%d|——|红左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }


            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|黑结点:%d|——|黑左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }

        } else if(node->lchild == NULL && node->rchild != NULL ){

            if(node->rchild->colour == 0 ){
                printf("(|黑结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }


            if(node->rchild->colour == 1 ){
                printf("(|黑结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }

        } else {
            printf("(|黑结点:%d|——|左空|——|右空|)\n", node->key);
        }
    }
    //---------------------
    if(node->lchild != NULL){
        //printf("遍历结点%d左子树\n",node->key);
        show_rb_tree(node->lchild);
    }
    if(node->rchild != NULL){
        //printf("遍历结点%d右子树\n",node->key);
        show_rb_tree(node->rchild);
    }



    //printf("[0]\n");
}

void rb_delete(int key){
    rb_node *v = rb_search(key), *u, *p, *c, *b;
    int tmp;
    if(v == NULL) return;

    u = v;
    if(v->lchild != NULL && v->rchild != NULL){
        u = v->rchild;
        while(u->lchild != NULL){
            u = u->lchild;
        }
        tmp = u->key;
        u->key = v->key;
        v->key = tmp;
    }

    //u is the node to free.
    if(u->lchild != NULL)
        c = u->lchild;
    else 
        c = u->rchild;

    p = u->parent;
    if(p != NULL){
        //remove u from rb_tree.
        if(p->lchild == u)
            p->lchild = c;
        else
            p->rchild = c;
    }
    else{
        //u is root.
        root = c;
        free((void*)u);
        return;
    }

    //u is not root and u is RED, this will not unbalance.
    if(u->colour == RED){
        free((void*)u);
        return;
    }

    free((void*)u);
    u = c;

    //u is the first node to balance.
    while(u != root){
        if(u != NULL && u->colour == RED){
            //if u is RED, change it to BLACK can finsh.
            u->colour = BLACK;
            return;
        }

        if(u == p->lchild)
            b = p->rchild;
        else 
            b = p->lchild;

        printf("%d\n", b->key);

        //b is borther of u. b can't be null, or the rb_tree is must not balance.
        if(b->colour == BLACK){
            //If b's son is RED, rotate the node.
            if(b->lchild != NULL && b->lchild->colour == RED){
                if(u == p->lchild){
                    b = clock_wise(b);
                    b->colour = BLACK;
                    b->rchild->colour = RED;

                    p = counter_clock_wise(p);
                    p->colour = p->lchild->colour;
                    p->lchild->colour = BLACK;
                    p->rchild->colour = BLACK;
                }
                else{
                    p = clock_wise(p);
                    p->colour = p->rchild->colour;
                    p->rchild->colour = BLACK;
                    p->lchild->colour = BLACK;
                }

                return;
            }
            else if(b->rchild != NULL && b->rchild->colour == RED){
                if(u == p->rchild){
                    b = counter_clock_wise(b);
                    b->colour = BLACK;
                    b->lchild->colour = RED;

                    p = clock_wise(p);
                    p->colour = p->rchild->colour;
                    p->rchild->colour = BLACK;
                    p->lchild->colour = BLACK;
                }
                else{
                    p = counter_clock_wise(p);
                    p->colour = p->lchild->colour;
                    p->lchild->colour = BLACK;
                    p->rchild->colour = BLACK;
                }        
                return;
            }
            else{//if b's sons are BLACK, make b RED and move up u.
                b->colour = RED;
                u = p;
                p = u->parent;
                continue;
            }
        }
        else{
            if(u == p->lchild){
                p = counter_clock_wise(p);
                p->colour = BLACK;
                p->lchild->colour = RED;
                p = p->lchild;
            }
            else{
                p = clock_wise(p);
                p->colour = BLACK;
                p->rchild->colour = RED;
                p = p->rchild;
            }
        }
    }
    root->colour = BLACK;
}




int main(){
    int i;
    root = NULL;
    int N = 10 ; // 循环次数
    for(i = 1; i <= N; i++){    
        rb_insert(i);
    }
    rb_delete(9);
    rb_delete(3);
    rb_delete(7);
    printf("根节点%d\n",root->key);
    show_rb_tree(root);
    printf("\n");

    printf("删除根节点节点%d后:\n",root->key);
    int  rootValue = root->key ;
    rb_delete(root->key);
    printf("当前根节点%d\n",root->key);
    show_rb_tree(root);
    printf("\n");

    printf("插入原根节点后 %d:\n",rootValue);
    rb_insert(rootValue);
    printf("当前根节点%d\n",root->key);
    show_rb_tree(root);
    printf("\n");

    for(i = 1; i <= N; i++){
        rb_node* node = rb_search(i);
        if( node != NULL ){
            if(node->colour == 0){
                printf("node%d的颜色是 红\n",i);
            }else{
                printf("node%d的颜色是 黑\n",i);
            }

        } else{
            printf("node%d不存在\n",i);
        }
    }



    return 0;
}
//输出结果:
//1
//6
//10
//4
//根节点6
//(|黑结点:6|——|红左结点:4|——|黑右结点:8|)
//(|红结点:4|——|黑左结点:2|——|黑右结点:5|)
//(|黑结点:2|——|红左结点:1|——|右空|)
//(|红结点:1|——|左空|——|右空|)
//(|黑结点:5|——|左空|——|右空|)
//(|黑结点:8|——|左空|——|红右结点:10|)
//(|红结点:10|——|左空|——|右空|)
//删除根节点节点6后:
//当前根节点8
//(|黑结点:8|——|红左结点:4|——|黑右结点:10|)
//(|红结点:4|——|黑左结点:2|——|黑右结点:5|)
//(|黑结点:2|——|红左结点:1|——|右空|)
//(|红结点:1|——|左空|——|右空|)
//(|黑结点:5|——|左空|——|右空|)
//(|黑结点:10|——|左空|——|右空|)
//插入原根节点后 6:
//当前根节点8
//(|黑结点:8|——|红左结点:4|——|黑右结点:10|)
//(|红结点:4|——|黑左结点:2|——|黑右结点:5|)
//(|黑结点:2|——|红左结点:1|——|右空|)
//(|红结点:1|——|左空|——|右空|)
//(|黑结点:5|——|左空|——|红右结点:6|)
//(|红结点:6|——|左空|——|右空|)
//(|黑结点:10|——|左空|——|右空|)
//node1的颜色是 红
//node2的颜色是 黑
//node3不存在
//node4的颜色是 红
//node5的颜色是 黑
//node6的颜色是 红
//node7不存在
//node8的颜色是 黑
//node9不存在
//node10的颜色是 黑
//

http://www.runoob.com/try/runcode.php?filename=helloworld&type=c 【C语言在线编译】

// 红黑树的C语言实现
#include <stdio.h>
#include <stdlib.h>
const int RED = 0;
const int BLACK = 1;

//---编译条件严格，自己引用自己 需要额外定义一个数据类型 使用typedef关键字
/*  https://tool.lu/coderunner/
struct rb_node_p;
typedef struct rb_node_p rb_node;

struct rb_node_p{
    rb_node* lchild, *rchild, *parent;
    int key, colour;
};
*/

/*  http://www.runoob.com/try/runcode.php?filename=helloworld&type=c
struct rb_node{
    rb_node* lchild, *rchild, *parent;
    int key, colour;
};

*/
//------------------------

struct rb_node{
    rb_node* lchild, *rchild, *parent;
    int key, colour;
};

rb_node* root;

rb_node* get_node( rb_node* parent, int key);
void rb_insert(int key);
rb_node* rb_search(int key);
void rb_delete(int key);
rb_node* clock_wise( rb_node* node);
rb_node* counter_clock_wise( rb_node* node);
void show_rb_tree( rb_node* node);

rb_node* get_node( rb_node* parent, int key){
    rb_node *tmp = (rb_node*)malloc(sizeof(rb_node));
    tmp->key = key;
    tmp->colour = RED;
    tmp->parent = parent;
    tmp->lchild = tmp->rchild = NULL;
    return tmp;
}

rb_node* clock_wise(rb_node* node){
    if(node == NULL || node->lchild == NULL)
        return NULL;

    rb_node *rb_1=node, *rb_2=node->lchild, *rb_3=node->lchild->rchild;
    if(rb_1->parent != NULL){
        if(rb_1->parent->lchild == rb_1)
            rb_1->parent->lchild = rb_2;
        else
            rb_1->parent->rchild = rb_2;
    }else if(rb_1 == root){
        root = rb_2;
    }
    rb_2->parent = rb_1->parent;

    rb_1->parent = rb_2;
    rb_2->rchild = rb_1;

    rb_1->lchild = rb_3;
    if(rb_3 != NULL)rb_3->parent = rb_1;

    return rb_2;    
}

rb_node* counter_clock_wise(rb_node* node){
    if(node == NULL || node->rchild == NULL)
        return NULL;

    rb_node *rb_1=node, *rb_2=node->rchild, *rb_3=node->rchild->lchild;
    if(rb_1->parent != NULL){
        if(rb_1->parent->lchild == rb_1)
            rb_1->parent->lchild = rb_2;
        else 
            rb_1->parent->rchild = rb_2;
    }
    else if(rb_1 == root){
        root = rb_2;
    }
    rb_2->parent = rb_1->parent;

    rb_1->parent = rb_2;
    rb_2->lchild = rb_1;

    rb_1->rchild = rb_3;
    if(rb_3 != NULL)rb_3->parent = rb_1;

    return rb_2;
}

rb_node* rb_search(int key){
    rb_node *p = root;
    while(p != NULL){
        if(key < p->key)
            p = p->lchild;
        else if(key > p->key)
            p = p->rchild;
        else
            break;
    }
    return p;
}

void rb_insert(int key){
    rb_node *p=root, *q=NULL;

    if(root == NULL){
        root = get_node(NULL, key);
        root->colour = BLACK;
        return;
    }

    while(p != NULL){
        q = p;
        if(key < p->key)
            p = p->lchild;
        else if(key > p->key)
            p = p->rchild;
        else return;
    }

    if(key < q->key)
        q->lchild = get_node(q, key);
    else
        q->rchild = get_node(q, key);

    while(q != NULL && q->colour == RED){
        p = q->parent;//p won't null, or BUG.

        if(p->lchild == q){
            if(q->rchild != NULL && q->rchild->colour == RED)
                counter_clock_wise(q);        
            q = clock_wise(p);
            q->lchild->colour = BLACK;
        }
        else{
            if(q->lchild != NULL && q->lchild->colour == RED)
                clock_wise(q);
            q = counter_clock_wise(p);
            q->rchild->colour = BLACK;
        }

        q = q->parent;
    }
    root->colour = BLACK;
}

void show_rb_tree(rb_node* node){
    if(node == NULL)
        return;
    if(node->colour == 0){
        if(node->lchild != NULL && node->rchild != NULL){
            if(node->lchild->colour == 0 && node->rchild->colour == 0){
                printf("(|红结点:%d|——|红左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
            if(node->lchild->colour == 0 && node->rchild->colour == 1){
                printf("(|红结点:%d|——|红左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|红结点:%d|——|黑左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 1){
                printf("(|红结点:%d|——|黑左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
        } else if(node->lchild != NULL && node->rchild == NULL ){

            if(node->lchild->colour == 0 ){
                printf("(|红结点:%d|——|红左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }


            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|红结点:%d|——|黑左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }

        } else if(node->lchild == NULL && node->rchild != NULL ){

            if(node->rchild->colour == 0 ){
                printf("(|红结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }


            if(node->rchild->colour == 1 ){
                printf("(|红结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }

        } else {
            printf("(|红结点:%d|——|左空|——|右空|)\n", node->key);
        }
    }
    if(node->colour == 1){
        if(node->lchild != NULL && node->rchild != NULL){
            if(node->lchild->colour == 0 && node->rchild->colour == 0){
                printf("(|黑结点:%d|——|红左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
            if(node->lchild->colour == 0 && node->rchild->colour == 1){
                printf("(|黑结点:%d|——|红左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|黑结点:%d|——|黑左结点:%d|——|红右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }

            if(node->lchild->colour == 1 && node->rchild->colour == 1){
                printf("(|黑结点:%d|——|黑左结点:%d|——|黑右结点:%d|)\n", node->key,node->lchild->key,node->rchild->key);
            }
        } else if(node->lchild != NULL && node->rchild == NULL ){

            if(node->lchild->colour == 0 ){
                printf("(|黑结点:%d|——|红左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }


            if(node->lchild->colour == 1 && node->rchild->colour == 0){
                printf("(|黑结点:%d|——|黑左结点:%d|——|右空|)\n", node->key,node->lchild->key);
            }

        } else if(node->lchild == NULL && node->rchild != NULL ){

            if(node->rchild->colour == 0 ){
                printf("(|黑结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }


            if(node->rchild->colour == 1 ){
                printf("(|黑结点:%d|——|左空|——|红右结点:%d|)\n", node->key,node->rchild->key);
            }

        } else {
            printf("(|黑结点:%d|——|左空|——|右空|)\n", node->key);
        }
    }
    //---------------------
    if(node->lchild != NULL){
        //printf("遍历结点%d左子树\n",node->key);
        show_rb_tree(node->lchild);
    }
    if(node->rchild != NULL){
        //printf("遍历结点%d右子树\n",node->key);
        show_rb_tree(node->rchild);
    }



    //printf("[0]\n");
}

void rb_delete(int key){
    rb_node *v = rb_search(key), *u, *p, *c, *b;
    int tmp;
    if(v == NULL) return;

    u = v;
    if(v->lchild != NULL && v->rchild != NULL){
        u = v->rchild;
        while(u->lchild != NULL){
            u = u->lchild;
        }
        tmp = u->key;
        u->key = v->key;
        v->key = tmp;
    }

    //u is the node to free.
    if(u->lchild != NULL)
        c = u->lchild;
    else 
        c = u->rchild;

    p = u->parent;
    if(p != NULL){
        //remove u from rb_tree.
        if(p->lchild == u)
            p->lchild = c;
        else
            p->rchild = c;
    }
    else{
        //u is root.
        root = c;
        free((void*)u);
        return;
    }

    //u is not root and u is RED, this will not unbalance.
    if(u->colour == RED){
        free((void*)u);
        return;
    }

    free((void*)u);
    u = c;

    //u is the first node to balance.
    while(u != root){
        if(u != NULL && u->colour == RED){
            //if u is RED, change it to BLACK can finsh.
            u->colour = BLACK;
            return;
        }

        if(u == p->lchild)
            b = p->rchild;
        else 
            b = p->lchild;

        printf("%d\n", b->key);

        //b is borther of u. b can't be null, or the rb_tree is must not balance.
        if(b->colour == BLACK){
            //If b's son is RED, rotate the node.
            if(b->lchild != NULL && b->lchild->colour == RED){
                if(u == p->lchild){
                    b = clock_wise(b);
                    b->colour = BLACK;
                    b->rchild->colour = RED;

                    p = counter_clock_wise(p);
                    p->colour = p->lchild->colour;
                    p->lchild->colour = BLACK;
                    p->rchild->colour = BLACK;
                }
                else{
                    p = clock_wise(p);
                    p->colour = p->rchild->colour;
                    p->rchild->colour = BLACK;
                    p->lchild->colour = BLACK;
                }

                return;
            }
            else if(b->rchild != NULL && b->rchild->colour == RED){
                if(u == p->rchild){
                    b = counter_clock_wise(b);
                    b->colour = BLACK;
                    b->lchild->colour = RED;

                    p = clock_wise(p);
                    p->colour = p->rchild->colour;
                    p->rchild->colour = BLACK;
                    p->lchild->colour = BLACK;
                }
                else{
                    p = counter_clock_wise(p);
                    p->colour = p->lchild->colour;
                    p->lchild->colour = BLACK;
                    p->rchild->colour = BLACK;
                }        
                return;
            }
            else{//if b's sons are BLACK, make b RED and move up u.
                b->colour = RED;
                u = p;
                p = u->parent;
                continue;
            }
        }
        else{
            if(u == p->lchild){
                p = counter_clock_wise(p);
                p->colour = BLACK;
                p->lchild->colour = RED;
                p = p->lchild;
            }
            else{
                p = clock_wise(p);
                p->colour = BLACK;
                p->rchild->colour = RED;
                p = p->rchild;
            }
        }
    }
    root->colour = BLACK;
}




int main(){
    int i;
    root = NULL;
    int N = 10 ; // 循环次数
    for(i = 1; i <= N; i++){    
        rb_insert(i);
    }
    rb_delete(9);
    rb_delete(3);
    rb_delete(7);
    printf("根节点%d\n",root->key);
    show_rb_tree(root);
    printf("\n");

    printf("删除根节点节点%d后:\n",root->key);
    int  rootValue = root->key ;
    rb_delete(root->key);
    printf("当前根节点%d\n",root->key);
    show_rb_tree(root);
    printf("\n");

    printf("插入原根节点后 %d:\n",rootValue);
    rb_insert(rootValue);
    printf("当前根节点%d\n",root->key);
    show_rb_tree(root);
    printf("\n");

    for(i = 1; i <= N; i++){
        rb_node* node = rb_search(i);
        if( node != NULL ){
            if(node->colour == 0){
                printf("node%d的颜色是 红\n",i);
            }else{
                printf("node%d的颜色是 黑\n",i);
            }

        } else{
            printf("node%d不存在\n",i);
        }
    }



    return 0;
}
//输出结果:
//1
//6
//10
//4
//根节点6
//(|黑结点:6|——|红左结点:4|——|黑右结点:8|)
//(|红结点:4|——|黑左结点:2|——|黑右结点:5|)
//(|黑结点:2|——|红左结点:1|——|右空|)
//(|红结点:1|——|左空|——|右空|)
//(|黑结点:5|——|左空|——|右空|)
//(|黑结点:8|——|左空|——|红右结点:10|)
//(|红结点:10|——|左空|——|右空|)
//删除根节点节点6后:
//当前根节点8
//(|黑结点:8|——|红左结点:4|——|黑右结点:10|)
//(|红结点:4|——|黑左结点:2|——|黑右结点:5|)
//(|黑结点:2|——|红左结点:1|——|右空|)
//(|红结点:1|——|左空|——|右空|)
//(|黑结点:5|——|左空|——|右空|)
//(|黑结点:10|——|左空|——|右空|)
//插入原根节点后 6:
//当前根节点8
//(|黑结点:8|——|红左结点:4|——|黑右结点:10|)
//(|红结点:4|——|黑左结点:2|——|黑右结点:5|)
//(|黑结点:2|——|红左结点:1|——|右空|)
//(|红结点:1|——|左空|——|右空|)
//(|黑结点:5|——|左空|——|红右结点:6|)
//(|红结点:6|——|左空|——|右空|)
//(|黑结点:10|——|左空|——|右空|)
//node1的颜色是 红
//node2的颜色是 黑
//node3不存在
//node4的颜色是 红
//node5的颜色是 黑
//node6的颜色是 红
//node7不存在
//node8的颜色是 黑
//node9不存在
//node10的颜色是 黑
//
Zach-Zona
关注
专栏目录
红黑树--c语言实现
weixin_53272394的博客
07-25 1143
红黑树 红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求： 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。 性质3. 每个叶节点(NIL节点，空节点)是黑色的。 性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能
红黑树（C语言实现）
qq_49723651的博客
06-29 5126
红黑树c语言实现
红黑树（C++实现）
最新发布
2202_75331338的博客
07-22 1064
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
红黑树-C语言实现
binwin20
12-09 4219
红黑树的c语言实现。
红黑树（Red Black Tree）（C语言实现、200行精简版）
热门推荐
日常记录，挨打要立正！
08-14 1万+
红黑树详解与手动实现
红黑树c语言实现
09-29
红黑树是一种自平衡二叉...总结来说，红黑树的C语言实现涉及了数据结构、算法、内存管理和多线程同步等多个方面。理解并实现红黑树需要扎实的计算机科学基础，但一旦掌握，它将为高效的数据存储和检索提供强大支持。
红黑树C语言实现
04-06
红黑树的C语言实现，可以正常编译运行
红黑树C语言实现增删改查
12-09
用C语言写的红黑树，实现了增删改查， 程序一开始初始化了给定好的红黑树，并且用颜色形象的表示，所以分比较高。提示，需要用WINTC编译，因为用到了一个库函数上颜色，想用VC编译的童鞋，可以根据代码更改。核心...
红黑树C语言代码
03-19
7. **C语言实现**： - 在C语言中实现红黑树需要定义一个结构体来表示节点，包括键值、颜色、子节点指针等成员。同时，需要定义插入、删除、查找等操作的函数，每个函数都要考虑如何维护红黑树的性质。 通过理解并...
红黑树的完整C语言实现
01-20
红黑树的完整代码实现。按照算法导论给出的算法。附二叉查找树的完整代码。纯C语言实现。
红黑树的c语言代码实现
05-30
红黑树的代码实现。c语言版。原创的。参考算法导论。
LINUX红黑树的C语言实现
08-30
LINUX红黑树的C语言实现 VS2008编写。
用c语言实现红黑树
weixin_35752645的博客
01-05 291
红黑树是一种自平衡二叉查找树，它在保证对于任意一个节点，其子树中的所有节点的键值都大于等于(或小于等于)该节点的键值的同时，还能保证搜索、插入和删除的时间复杂度都是 O(log n)。 下面是用 C 语言实现红黑树的基本步骤： 定义结构体表示红黑树的节点，其中包含节点的键值、颜色(红或黑)、左右子节点和父节点指针。 typedefstruct rbtree_node_t { int k...
红黑树 (c实现)
slhywll的博客
01-16 1132
我们这里直接实现C语言的红黑树，为了方便后序的旋转操作，将红黑树的结点定义为三叉链结构，除此之外还新加入了一个成员变量，用于表示结点的颜色。int _data;
红黑树的C语言简单实现与代码解析
To learn, to engage.
12-23 965
红黑树是计算机科学中一种重要的自平衡二叉搜索树。它确保了在最坏情况下，基本的动态集合操作（如插入、删除和查找）具有对数时间复杂度。
C语言实现红黑树(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-22 800
C语言实现红黑树节点定义实现以下10个接口完整实现和main测试源码 节点定义 typedef struct node { int val; struct node *par; struct node *left; struct node *right; int color; } Node; 实现以下10个接口 Node *newNode(int val, Node *par); int isLeaf(Node *n); Node *leftRotate(Node
C语言编写红黑树
weixin_44269491的博客
01-04 430
一、平衡条件 节点非黑既红 根节点是黑色 叶子（NIL）结点是黑色 红色节点下面接两个黑色节点 从根节点到叶子结点路径上，黑色节点数量相同 注： 1. 第4条和第5条条件，注定了，红黑树中最长路径是最短路径的长度的 2 倍。 2. 本质上，红黑树也是通过树高来控制平衡的。 3. 红黑树比 AVL 树树高控制条件要更松散，红黑树在发生节点插入和删除以后，发生调整的概率，比 AVL 树要更小。 二、理解层面 理解红黑树的插入调整，要站在祖父节点向下进行调整 理解红黑树的删除调整，要站在父节点向下进行调整
C语言 红黑树
fpk2014的博客
05-29 720
红黑树简介 实现过程 代码实现 红黑树简介 红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。 红黑树的模拟过程可以看链接：InsertSortion 红黑树有五个性质: 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。 性质3. 每个叶节点（NIL节点，空节点）是黑色的。 性质4. 每个红色节点的两个子节...
理解红黑树：C语言实现与分析
"红黑树是一种自平衡二叉查找树，由C语言实现，源代码包含详细注释，便于理解。文件是黄乐君在中国科学技术大学编写，日期为2011年3月20日。该代码实现了红黑树的基本操作，包括插入、删除、搜索，以及计算树的黑高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值