0
点赞
收藏
分享

微信扫一扫

基于C语言的红黑树原理入门

那小那小 2024-07-26 阅读 11
红黑树删除操作二叉搜索树Python后端开发

红黑树是一种自平衡二叉搜索树，它通过添加额外的属性和规则来保证树的高度平衡，从而提高查找、插入和删除操作的效率。下面我们一步一步地阐述红黑树的核心方法、核心步骤和核心策略。

1. 红黑树的基本概念

1.1 二叉搜索树

红黑树基于二叉搜索树构建。二叉搜索树是一种每个节点最多有两个子节点的树结构，其中每个节点包含一个值，左子节点的值小于父节点，右子节点的值大于父节点。

1.2 红黑树的特点

红黑树在普通二叉搜索树的基础上增加了以下性质：

  1. 节点要么是红色，要么是黑色。
  2. 根节点是黑色。
  3. 叶子节点（NIL节点）是黑色。
  4. 如果一个节点是红色，则它的子节点必须是黑色（即不存在两个连续的红色节点）。
  5. 从任一节点到其每个叶子节点的所有路径都包含相同数量的黑色节点。

这些性质确保了红黑树的平衡性，使其能够在O(log n)时间内完成插入、删除和查找操作。

2. 核心步骤

2.1 插入操作

插入新节点的步骤如下：

  1. 按照二叉搜索树的插入方式，将新节点插入到树中，并将其着色为红色。
  2. 检查并修复红黑树的性质。如果违反了红黑树的性质，通过旋转和重新着色来调整。

2.2 删除操作

删除节点的步骤如下：

  1. 按照二叉搜索树的删除方式，将节点删除。
  2. 检查并修复红黑树的性质。如果违反了红黑树的性质，通过旋转和重新着色来调整。

3. 核心策略

3.1 旋转操作

红黑树的旋转操作有两种：左旋和右旋。旋转操作用于调整树的结构，保持红黑树的性质。

3.2 重新着色

在插入和删除操作中，通过重新着色来保持红黑树的性质。例如，如果插入节点后出现两个连续的红色节点，可以通过调整节点的颜色来解决。

4. 实验设计与实现

4.1 实验设计

设计实验来验证红黑树的性质和性能。可以生成随机数据集并进行插入、删除和查找操作，记录每次操作的时间和树的高度。

4.2 C语言实现

用C语言实现红黑树的插入、删除和查找操作。包括定义节点结构，编写插入、删除和修复函数。

5. 解决问题的方法

红黑树通过保持高度平衡来提高查找、插入和删除操作的效率。相比于普通的二叉搜索树，红黑树能够避免最坏情况（退化为链表），从而提高了整体性能。

基于C语言实现红黑树的插入、删除和查找操作

红黑树的实现可以分为几个主要部分：定义节点结构、实现插入操作、删除操作以及查找操作。以下是详细的代码示例和说明。

1. 定义节点结构

首先，我们需要定义红黑树的节点结构和红黑树本身的结构。

#include <stdio.h>
#include <stdlib.h>

typedef enum { RED, BLACK } NodeColor;

typedef struct RBTreeNode {
    int data;
    NodeColor color;
    struct RBTreeNode *left, *right, *parent;
} RBTreeNode;

typedef struct RBTree {
    RBTreeNode *root;
    RBTreeNode *nil; // 用于表示NIL节点
} RBTree;

2. 辅助函数

在实现插入和删除操作之前，我们需要一些辅助函数，如左旋、右旋和修复函数。

2.1 左旋操作

void leftRotate(RBTree *tree, RBTreeNode *x) {
    RBTreeNode *y = x->right;
    x->right = y->left;
    if (y->left != tree->nil) {
        y->left->parent = x;
    }
    y->parent = x->parent;
    if (x->parent == tree->nil) {
        tree->root = y;
    } else if (x == x->parent->left) {
        x->parent->left = y;
    } else {
        x->parent->right = y;
    }
    y->left = x;
    x->parent = y;
}

2.2 右旋操作

void rightRotate(RBTree *tree, RBTreeNode *x) {
    RBTreeNode *y = x->left;
    x->left = y->right;
    if (y->right != tree->nil) {
        y->right->parent = x;
    }
    y->parent = x->parent;
    if (x->parent == tree->nil) {
        tree->root = y;
    } else if (x == x->parent->right) {
        x->parent->right = y;
    } else {
        x->parent->left = y;
    }
    y->right = x;
    x->parent = y;
}

2.3 插入修复函数

void insertFixUp(RBTree *tree, RBTreeNode *z) {
    while (z->parent->color == RED) {
        if (z->parent == z->parent->parent->left) {
            RBTreeNode *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;
                    leftRotate(tree, z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                rightRotate(tree, z->parent->parent);
            }
        } else {
            RBTreeNode *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;
                    rightRotate(tree, z);
                }
                z->parent->color = BLACK;
                z->parent->parent->color = RED;
                leftRotate(tree, z->parent->parent);
            }
        }
    }
    tree->root->color = BLACK;
}

3. 插入操作

void rbInsert(RBTree *tree, int data) {
    RBTreeNode *z = (RBTreeNode *)malloc(sizeof(RBTreeNode));
    z->data = data;
    z->color = RED;
    z->left = z->right = z->parent = tree->nil;

    RBTreeNode *y = tree->nil;
    RBTreeNode *x = tree->root;

    while (x != tree->nil) {
        y = x;
        if (z->data < x->data) {
            x = x->left;
        } else {
            x = x->right;
        }
    }

    z->parent = y;
    if (y == tree->nil) {
        tree->root = z;
    } else if (z->data < y->data) {
        y->left = z;
    } else {
        y->right = z;
    }

    z->left = z->right = tree->nil;
    z->color = RED;

    insertFixUp(tree, z);
}

4. 删除操作

4.1 删除修复函数

void deleteFixUp(RBTree *tree, RBTreeNode *x) {
    while (x != tree->root && x->color == BLACK) {
        if (x == x->parent->left) {
            RBTreeNode *w = x->parent->right;
            if (w->color == RED) {
                w->color = BLACK;
                x->parent->color = RED;
                leftRotate(tree, x->parent);
                w = x->parent->right;
            }
            if (w->left->color == BLACK && w->right->color == BLACK) {
                w->color = RED;
                x = x->parent;
            } else {
                if (w->right->color == BLACK) {
                    w->left->color = BLACK;
                    w->color = RED;
                    rightRotate(tree, w);
                    w = x->parent->right;
                }
                w->color = x->parent->color;
                x->parent->color = BLACK;
                w->right->color = BLACK;
                leftRotate(tree, x->parent);
                x = tree->root;
            }
        } else {
            RBTreeNode *w = x->parent->left;
            if (w->color == RED) {
                w->color = BLACK;
                x->parent->color = RED;
                rightRotate(tree, x->parent);
                w = x->parent->left;
            }
            if (w->right->color == BLACK && w->left->color == BLACK) {
                w->color = RED;
                x = x->parent;
            } else {
                if (w->left->color == BLACK) {
                    w->right->color = BLACK;
                    w->color = RED;
                    leftRotate(tree, w);
                    w = x->parent->left;
                }
                w->color = x->parent->color;
                x->parent->color = BLACK;
                w->left->color = BLACK;
                rightRotate(tree, x->parent);
                x = tree->root;
            }
        }
    }
    x->color = BLACK;
}

4.2 删除操作

void rbDelete(RBTree *tree, RBTreeNode *z) {
    RBTreeNode *y = z;
    RBTreeNode *x;
    NodeColor yOriginalColor = y->color;

    if (z->left == tree->nil) {
        x = z->right;
        rbTransplant(tree, z, z->right);
    } else if (z->right == tree->nil) {
        x = z->left;
        rbTransplant(tree, z, z->left);
    } else {
        y = treeMinimum(tree, z->right);
        yOriginalColor = y->color;
        x = y->right;
        if (y->parent == z) {
            x->parent = y;
        } else {
            rbTransplant(tree, y, y->right);
            y->right = z->right;
            y->right->parent = y;
        }
        rbTransplant(tree, z, y);
        y->left = z->left;
        y->left->parent = y;
        y->color = z->color;
    }

    if (yOriginalColor == BLACK) {
        deleteFixUp(tree, x);
    }
    free(z);
}

4.3 辅助删除操作函数

void rbTransplant(RBTree *tree, RBTreeNode *u, RBTreeNode *v) {
    if (u->parent == tree->nil) {
        tree->root = v;
    } else if (u == u->parent->left) {
        u->parent->left = v;
    } else {
        u->parent->right = v;
    }
    v->parent = u->parent;
}

RBTreeNode* treeMinimum(RBTree *tree, RBTreeNode *node) {
    while (node->left != tree->nil) {
        node = node->left;
    }
    return node;
}

5. 查找操作

RBTreeNode* rbSearch(RBTree *tree, int data) {
    RBTreeNode *current = tree->root;
    while (current != tree->nil && current->data != data) {
        if (data < current->data) {
            current = current->left;
        } else {
            current = current->right;


        }
    }
    return current;
}

6. 初始化和测试

6.1 初始化红黑树

RBTree* createRBTree() {
    RBTree *tree = (RBTree *)malloc(sizeof(RBTree));
    tree->nil = (RBTreeNode *)malloc(sizeof(RBTreeNode));
    tree->nil->color = BLACK;
    tree->root = tree->nil;
    return tree;
}

6.2 测试代码

int main() {
    RBTree *tree = createRBTree();

    rbInsert(tree, 10);
    rbInsert(tree, 20);
    rbInsert(tree, 30);
    rbInsert(tree, 15);

    RBTreeNode *node = rbSearch(tree, 20);
    if (node != tree->nil) {
        printf("Found node with data: %d\n", node->data);
    } else {
        printf("Node not found\n");
    }

    rbDelete(tree, node);

    node = rbSearch(tree, 20);
    if (node != tree->nil) {
        printf("Found node with data: %d\n", node->data);
    } else {
        printf("Node not found\n");
    }

    return 0;
}

进一步的思考和问题

  1. 如何实现红黑树的遍历操作？
  2. 红黑树的删除操作为什么比插入操作更复杂？
  3. 在插入和删除操作中，为什么需要进行旋转和重新着色？
  4. 如何处理红黑树中节点的内存管理问题？
  5. 如何优化红黑树的插入和删除操作？
  6. 红黑树在实际应用中有哪些场景？
  7. 与其他平衡树（如AVL树）相比，红黑树有哪些优势和劣势？
  8. 如何调试红黑树的实现，确保其正确性？
  9. 如何在红黑树中实现键值对的存储和查找？
  10. 如何扩展红黑树的实现，使其支持多线程操作？

通过这些问题，可以进一步加深对红黑树的理解和应用。

举报

相关推荐

红黑树-数据结构(c语言)

数据结构b树

C++_红黑树

rust开发语言后端

C++【红黑树】

人工智能线性回归分类

C++红黑树

matlab分类预测多标签多分类catboost

【C++】红黑树

算法java深度优先蓝桥杯

c++-红黑树

c语言数据结构1024程序员节开发语言

C++：红黑树

angular.js前端javascript

红黑树 图解快速入门

b树数据结构算法

红黑树的原理及实现（TypeScript）

数据结构

红黑树原理及java实现

java数据结构算法二叉树
0 条评论