数据结构基础-二叉排序树的删除操作

已于 2023-12-26 12:13:52 修改
阅读量718 收藏 11
点赞数 9
分类专栏： 数据结构与算法基础 文章标签： 算法 数据结构 c语言
于 2023-12-24 23:09:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72324401/article/details/135188706
版权

一棵搜索二叉树的结点的度有以下三种情况：0 1 2

那我们就需要依据节点不同的度进行不同的讨论

假设被删除的节点是node，我们仍然需要考虑该node是否为根节点，因为根节点无双亲结点，其索引只有一个root指针

情况一：node没有孩子，是叶子结点，度为0，直接free该节点的分配空间

(1) node不是根节点，直接把node删除，把node父亲对应的孩子指针置空

(2) node是根节点，直接删除，把根指针置空

情况二：node只有一个孩子节点，节点度为1

(1) node不是根节点，并且node只有一个孩子，就让这个孩子节点顶替node的位置，也就是node的parent的指向node的指针，要去指向该孩子

(2) node是根节点，让根指针直接指向node的唯一孩子即可，当然了先需要移动root指针，另外将原根节点free

情况三：node有两个孩子，节点度为2

我们从排序的中序序列来观察一下

假如该序列的顺序排序为：1 3 4 6 7 8 10 13 14，且该树的根节点为8，如果删除节点8的话，新树的排序为：

1 3 4 6 7 10 13 14

那么要么我们将节点7移到8的位置

或者10代替8向前移

都可以解决该问题，7是左子树中最靠右的节点，10是右子树中的根节点，是原节点8的左膀右臂

法1：让node节点的左子树中的最大值x来替换node节点的值，转化为删除x所在节点：如果x是叶子结点转化为情况一，如果x不是叶子结点转化为情况二(x只有左孩子) x是node左子树最靠右的节点

法2：让node节点的左子树中的最小值x来替换node节点的值，转化为删除x所在节点：如果x是叶子结点转化为情况一，如果x不是叶子结点转化为情况二(x只有右孩子) x是node右子树最靠左的节点

所以综上所述

①.对于叶子结点的删除，保存其父亲节点位置后，直接删除该叶子结点，令其父亲节点指向它的指针指向NULL；

②.对于度为1的节点删除，保存该节点的父亲节点位置后，另其父亲节点指向该节点的指针，指向其唯一的左/右孩子，然后删除该节点即可；

(针对以上两个类型的节点，我们都需要判断其是否为根节点，如果是根节点就要做根指针的替换，如指向NULL或者换成其对应的左/右孩子)

③.对于度为2的节点删除，通过分析我们知道了，我们需要找的是度为2的节点，在中序序列中的，前驱和后继，用以替换其位置，因为其本身具有特殊性，不能像度为0或者1的节点一样直接进行节点的删除和双亲结点指针的变换，以满足新的二叉搜索树仍然保持一个顺序序列。

所以我们通过寻找其前驱后继结点进行替换的方法，先进行数据上的整体替换，达到顺序序列的要求，然后再对被替换的(此时被替换结点成为了多余节点，即需要删除节点)进行删除操作，仍然是分析该节点的情况，其度为0或1，然后对应节点度进行情况一、二的结点的修正，完成一个节点的删除。

下面是代码操作：

//删除值为k的节点
void delete(int key){
    Node *node = root;
    Node *pre = NULL;
    if(node!=NULL){
        while(node->data != key){
            pre = node;
            if(key < node->data){
                node = node->left;
            }
            else if(key > node->data){
                node = node->right;
            }
        }
        if(node->left == NULL && node->right == NULL){//情况一，度为0的节点
            if(pre==NULL){//node的父亲为空，那么node为根节点
                root = NULL;
                free(node);
                node = NULL;//野指针
            }
            else{
                if(pre->left == node){
                    pre->left = NULL;
                    free(node);
                    node == NULL;
                }
                else{
                    pre->right == NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        
        //情况二-1
        else if(node->left != NULL && node->right == NULL){
            if(pre == NULL){
                root = node->left;
                node->left = NULL;
                free(node);
                node = NULL;
            }
            else{
                if(node == pre->left){
                    pre->left = node->left;
                    node->left = NULL;
                    free(node);
                    node = NULL;
                }
                else{
                    pre->right = node->left;
                    node->left = NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        //情况二-2
        else if(node->left == NULL && node->right != NULL){
            if(pre == NULL){
                root = node->right;
                node->right = NULL;
                free(node);
                node = NULL;
            }
            else{
                if(node == pre->left){
                    pre->left = node->right;
                    node->right = NULL;
                    free(node);
                    node = NULL;
                }
                else{
                    pre->right = node->right;
                    node->right = NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        
        //情况三
        else{
            Node *x = node->left;//这里使用上述的方法一，找左子树的最右节点
            Node *prex = node;//节点x的父亲节点，用于改变节点指针连通和赋值
            while(x->right!=NULL){
                prex = x;
                x = x->right;//一直往右走，中序序列就是这样的
            }
            node->data = x->data;
            if(prex == node){
                //如果prex是根节点，即node没有右子树，只有左子树，找到的最右节点就是x，即node->left
                node->left = x->left;
                free(x);
                x = NULL;
            }
            else{
                //存在右子树也找到了右子树中的最右节点x
                prex->right = NULL;
                free(x);
                x = NULL;
            }
        }
    }
}

上述代码为了描述更直观，将左右孩子节点的命名改为了left和right，但是为了操作方便和上一个二叉搜索树的代码对接，这里再统一改一下命名(视频里上下节老师的存储结构设置的不一样)

//删除值为k的节点
void delete(int key){
    Node *node = root;
    Node *pre = NULL;
    if(node!=NULL){
        //寻找节点
        while(node->data != key){
            pre = node;
            if(key < node->data){
                node = node->l;
            }
            else if(key > node->data){
                node = node->r;
            }
            if(node==NULL){
                printf("查无此数据\n");
                return;
            }
        }
        //编译异常说明node指向空后无值，无法调用(如果不加最后的if判断的话)
        if(node->l == NULL && node->r == NULL){
            //情况一，度为0的节点
            if(pre==NULL){
                //若node的父亲为空，那么node为根节点
                root = NULL;
                free(node);
                node = NULL;//野指针
            }
            else{
                //pre不为空，说明找到了对应的node->data == key
                if(pre->l == node){
                    //还要判断node是pre节点的左孩子还是右孩子
                    pre->l = NULL;
                    free(node);
                    node == NULL;
                }
                else{
                    pre->r == NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        
        //情况二-1 找到的node，node的度为1，找到了该节点的左孩子非空，没有右孩子
        else if(node->l != NULL && node->r == NULL){
            if(pre == NULL){
                //仍然是判断是否删除的为根节点
                root = node->l;
                node->l = NULL;
                free(node);
                node = NULL;
            }
            else{
                //再次判断node节点属于是pre的左孩子还是右孩子
                if(node == pre->l){
                    pre->l = node->l;
                    node->l = NULL;
                    //针对node的左孩子的继承(pre->left = node->left)
                    free(node);
                    node = NULL;
                }
                else{
                    pre->r = node->l;
                    //针对node的左孩子的继承(pre->right = node->left)
                    node->l = NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        //情况二-2找到的node，node的度为1，找到了该节点的右孩子非空，没有左孩子
        else if(node->l == NULL && node->r != NULL){
            //下面的代码和上面的内容基本相似
            if(pre == NULL){
                root = node->r;
                node->r = NULL;
                free(node);
                node = NULL;
            }
            else{
                if(node == pre->l){
                    pre->l = node->r;
                    node->r = NULL;
                    free(node);
                    node = NULL;
                }
                else{
                    pre->r = node->r;
                    node->r = NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        
        //情况三 找到的node节点的度为2 使用方法一处理该内容 即寻找node左子树的最右节点
        else{
            //这里设置新的指针进行赋值是必要的，因为要保留node节点的位置，删除的是其代替的节点
            Node *x = node->l;//这里使用上述的方法一，找左子树的最右节点
            Node *prex = node;//节点x的父亲节点，用于改变节点指针连通和赋值
            while(x->r!=NULL){
                prex = x;
                x = x->r;//一直往右走，中序序列就是这样的
            }
            node->data = x->data;
            if(prex == node){
                //如果prex是根节点，即node没有右子树，只有左子树，找到的最右节点就是x，即node->left
                node->l = x->l;
                free(x);
                x = NULL;
            }
            else{
                //存在右子树也找到了右子树中的最右节点x
                prex->r = NULL;
                free(x);
                x = NULL;
            }
        }
    }
}

然后把它再加入到二叉搜索树的整体代码中，回顾“二叉排序树概述及其插入操作”章节末代码

#include <stdio.h>
#include <stdlib.h>
​
//树节点
typedef struct BTNode{
    struct BTNode *l;
    struct BTNode *r;
    int data;
}Node;
Node *root = NULL;//根指针
​
int SearchKey(int key){
    Node *p = root;
    //不使用递归
    while(p!=NULL){
        if(p->data==key){
            //找到key，返回1
            return 1;
        }
        else if(p->data > key){
            p = p->l;
        }
        else{
            p = p->r;
        }
    }
    //没有找到key，返回0
    return 0;
}
​
//插入一个数据x
void insert(int x){
    Node *p = root;
    Node *pre = NULL;//一直指向p的双亲结点
    while(p!=NULL){
        //通过while循环找到插入位置
        pre = p;
        if(x < p->data){
            p = p->l;
        }
        else if(x > p->data){
            //这里必须使用else if，因为在这个while代码块中我们一直在变动指针p的位置，如果再进行x的判断可能会出现p为NULL的情况
            p = p->r;
        }
    }
    //核心仍然是查找
    if(x < pre->data){
        pre->l = (Node*)malloc(sizeof(Node));
        pre->l->data = x;
        pre->l->l = NULL;
        pre->l->r = NULL;
    }
    //这里使用if或者else if就没什么差别了，用了else少进行一次判断，因为这里的pre不会再发生改变
    else if(x > pre->data){
        pre->r = (Node*)malloc(sizeof(Node));
        pre->r->data = x;
        pre->r->l = NULL;
        pre->r->r = NULL;
    }
}
​
//中序遍历二叉搜索树
void inshow(Node *root)
{
    if(root==NULL){
        return;
    }
    if(root->l != NULL){
        inshow(root->l);
    }
    printf("%d ",root->data);
    if(root->r != NULL){
        inshow(root->r);
    }
}
​
//先初始化一个根节点用于后续操作
void initTree(int key){
    root = (Node*)malloc(sizeof(Node));
    root->data = 3;
    root->l = NULL;
    root->r = NULL;
}
​
//删除值为k的节点
void deleteNode(int key){
    Node *node = root;
    Node *pre = NULL;
    if(node!=NULL){
        //寻找节点
        while(node->data != key){
            pre = node;
            if(key < node->data){
                node = node->l;
            }
            else if(key > node->data){
                node = node->r;
            }
            if(node==NULL){
                printf("查无此数据\n");
                return;
            }
        }
        //编译异常说明node指向空后无值，无法调用(如果不加最后的if判断的话)
        if(node->l == NULL && node->r == NULL){
            //情况一，度为0的节点
            if(pre==NULL){
                //若node的父亲为空，那么node为根节点
                root = NULL;
                free(node);
                node = NULL;//野指针
            }
            else{
                //pre不为空，说明找到了对应的node->data == key
                if(pre->l == node){
                    //还要判断node是pre节点的左孩子还是右孩子
                    pre->l = NULL;
                    free(node);
                    node == NULL;
                }
                else{
                    pre->r == NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        
        //情况二-1 找到的node，node的度为1，找到了该节点的左孩子非空，没有右孩子
        else if(node->l != NULL && node->r == NULL){
            if(pre == NULL){
                //仍然是判断是否删除的为根节点
                root = node->l;
                node->l = NULL;
                free(node);
                node = NULL;
            }
            else{
                //再次判断node节点属于是pre的左孩子还是右孩子
                if(node == pre->l){
                    pre->l = node->l;
                    node->l = NULL;
                    //针对node的左孩子的继承(pre->left = node->left)
                    free(node);
                    node = NULL;
                }
                else{
                    pre->r = node->l;
                    //针对node的左孩子的继承(pre->right = node->left)
                    node->l = NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        //情况二-2找到的node，node的度为1，找到了该节点的右孩子非空，没有左孩子
        else if(node->l == NULL && node->r != NULL){
            //下面的代码和上面的内容基本相似
            if(pre == NULL){
                root = node->r;
                node->r = NULL;
                free(node);
                node = NULL;
            }
            else{
                if(node == pre->l){
                    pre->l = node->r;
                    node->r = NULL;
                    free(node);
                    node = NULL;
                }
                else{
                    pre->r = node->r;
                    node->r = NULL;
                    free(node);
                    node = NULL;
                }
            }
        }
        
        //情况三 找到的node节点的度为2 使用方法一处理该内容 即寻找node左子树的最右节点
        else{
            //这里设置新的指针进行赋值是必要的，因为要保留node节点的位置，删除的是其代替的节点
            Node *x = node->l;//这里使用上述的方法一，找左子树的最右节点
            Node *prex = node;//节点x的父亲节点，用于改变节点指针连通和赋值
            while(x->r!=NULL){
                prex = x;
                x = x->r;//一直往右走，中序序列就是这样的
            }
            node->data = x->data;
            if(prex == node){
                //如果prex是根节点，即node没有右子树，只有左子树，找到的最右节点就是x，即node->left
                node->l = x->l;
                free(x);
                x = NULL;
            }
            else{
                //存在右子树也找到了右子树中的最右节点x
                prex->r = NULL;
                free(x);
                x = NULL;
            }
        }
    }
}
​
//主函数
int main()
{
    initTree(3);
    inshow(root);
    printf("\n");
​
    insert(1);
    inshow(root);
    printf("\n");
​
    insert(2);
    inshow(root);
    printf("\n");
​
    insert(6);
    inshow(root);
    printf("\n");
​
    insert(5);
    inshow(root);
    printf("\n");
​
    insert(4);
    inshow(root);
    printf("\n");
​
    deleteNode(5);
    inshow(root);
    printf("\n");
    
    return 0;
}

可以通过在main函数中调用函数实现一下各种功能，可自行添加代码用于测试

上述程序运行结果为：

3

1 3

1 2 3

1 2 3 6

1 2 3 5 6

1 2 3 4 5 6

1 2 3 4 6

三好学生NX
关注
专栏目录
DS二叉排序树之删除
半途行走的博客
11-27 1401
题目描述 给出一个数据序列，建立二叉排序树，并实现删除功能 对二叉排序树进行中序遍历，可以得到有序的数据序列 输入 第一行输入t，表示有t个数据序列 第二行输入n，表示首个序列包含n个数据 第三行输入n个数据，都是自然数且互不相同，数据之间用空格隔开 第四行输入m，表示要删除m个数据 从第五行起，输入m行，每行一个要删除的数据，都是自然数 以此类推输入下一个示例 输出 第一...
排序二叉树的删除
weixin_45761237的博客
03-28 2393
排序二叉树的删除
二叉树——18.删除二叉搜索树中的节点
最新发布
plutomty的博客
08-22 755
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
二叉排序树的删除
实践求真知
03-25 3770
一点睛 二叉排序树的删除情况比较复杂，有下面三种情况需要考虑。 1 删除叶子节点。(比如：2,5,9,12)。 2 删除只有一颗子树的节点。(比如：1)。 3 删除有两颗子树的节点.。(比如：7,3,10 )。 二 思路分析 对删除结点的有三种情况需要分析。 第一种情况：删除叶子节点。(比如：2,5,9,12)。 (1) 需求先去找到要删除的结点 targetNode。 (2) 找到 targetNode 的 父结点 parent。 (3) 确定 targetNode 是 pare.
二叉排序树的删除操作
IT1995的博客
03-02 6355
二叉排序树的删除操作
数据结构实验-二叉排序树算法
10-26
掌握二叉排序树的存储方法，实现二叉排序树的创建、查找、插入、删除、平均查找长度等基本操作。 三、实验内容及要求 1、构造二叉排序树的存储结构。 2、实现创建、查找、插入、删除、平均查找长度等操作。
《数据结构与算法》-李春葆 实验报告-基于二叉链存储的树形结构算法实践-二叉排序树
12-20
这篇实验报告是关于《数据结构与算法》课程中的一次实践，主要涉及的是二叉链存储的树形结构，特别是二叉排序树的构建和操作。二叉排序树是一种特殊的二叉树，其中每个节点的左子树只包含比该节点小的元素，而右子树...
数据结构实验报告-二叉排序树.pdf
09-30
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都...通过实验报告，学生能够深入理解和掌握二叉排序树的原理及其操作，从而提升在数据结构和算法方面的实践能力。
数据结构基础之二叉排序树
02-26
二叉排序树（Binary Search Tree，BST）是一种特殊的二叉树...由于这些特性，二叉排序树常被用来实现动态集合的数据结构。在二叉排序树中，查找、插入和删除操作的平均时间复杂度均为O(log n)，其中n为树中节点的数量。
数据结构-二叉排序树
xiaosongshi的博客
06-30 581
二叉排序树
二叉排序树删除
weixin_52725999的博客
08-13 216
13.7.2 二叉排序树的删除 二叉排序树情况分为三种： 删除叶子节点 需要先找到要删除的节点 targetNode 找到targetNode的父节点 parent 确定 targetNode 是 parent的左子节点还是右子节点 根据前面的情况来对应删除 左子节点：parent.left = null 右子节点：parent.right = null 删除只有一棵子树的节点 需要先找到要删除的节点 targetNode 找到targetNode的父节点 parent 确定 targetN
Java数据结构和算法之二叉排序树
qq_43437122的博客
05-20 269
二叉排序树介绍 二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为： 二叉排序树的删除 二叉排序树的删除情况比较复杂，有下面三种情况需要考虑 删除叶子节点 (比如：2, 5, 9, 12) 删除只有一颗子树的节点 (比如：1) 删
数据结构——二叉排序树的删除操作（非递归）
xinzhi1992的博客
08-29 4990
二叉排序树的删除操作
树-排序二叉树删除
a925907195的专栏
09-28 855
相比较节点的添加，平衡二叉树的删除要复杂一些。因为在删除的过程中，你要考虑到不同的情况，针对每一种不同的情况，你要有针对性的反应和调整。所以在代码编写的过程中，我们可以一边写代码，一边写测试用例。编写测试用例不光可以验证我们编写的代码是否正确，还能不断提高我们开发代码的自信心。这样，即使我们在开发过程对代码进行修改或者优化也不会担心害怕。然而看起来编写测试用例是一个繁杂的过程，但是从长期的收益来看
排序二叉树删除操作
香酥蟹的博客
01-21 220
public class Solution { static class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } public TreeNode deleteNode(TreeNode root, int key) { if (root == null) { r
数据结构-二叉排序树的删除算法解析
"本文将探讨数据结构中的删除算法，特别是针对二叉排序树（BST）的删除操作。此外，还涵盖了查找表的基本概念，包括静态和动态查找表的定义、查找操作的描述以及查找表的结构优化。" 在数据结构中，删除算法是至关...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值