二叉搜索树的删除

最新推荐文章于 2024-10-14 23:32:49 发布

Shallow_Carl

最新推荐文章于 2024-10-14 23:32:49 发布

阅读量886

点赞数 1

分类专栏：蓝桥杯 LeetCode 文章标签：算法数据结构

本文链接：https://blog.csdn.net/Alanadle/article/details/122173407

版权

LeetCode 同时被 2 个专栏收录

39 篇文章 0 订阅

订阅专栏

蓝桥杯

13 篇文章 0 订阅

订阅专栏

题目描述

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；
如果找到了，删除它。

示例 1:

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点
示例 3:

输入: root = [], key = 0
输出: []

提示:

节点数的范围 [0, 104].
-105 <= Node.val <= 105
节点值唯一
root 是合法的二叉搜索树
-105 <= key <= 105

进阶：要求算法时间复杂度为 O(h)，h 为树的高度。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/delete-node-in-a-bst
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

说实话,我一开始也想到说找到它的前驱节点predecessor,后继者successor节点,但是我思考的中心是当前节点root的情况,分为三种情况:

a)root为叶子节点,直接删除

b)root左边有节点右边没有节点

c)root右边有节点,左边没有节点

d)root左边,右边都是有节点的

可是我思考的方向是:找到当前节点root的前驱节点和后继节点,然后进行指针操作,具体分类后我就放弃了,因为这样做实在太麻烦了......

思考了个把小时无果后果断选择看题解,得到了以下收获:

收获

根据二叉搜索树的性质,我们不需要移动它的左右指针,只需要将当前节点的val被覆盖成为(a,b,c,d)四种情况下的或后继节点或前驱节点的val ,然后再删除这个后继节点或者前驱节点.

后序节点代码:


    TreeNode* successor(TreeNode* root){
        root = root->right;
        while (root&&root->left) {              //如果root->right为空,返回NULL,否则返回他的后继节点
            root = root->left;
        }
        return root;
    }

前驱节点的代码:

TreeNode* predecessor(TreeNode* root) {     //如果root->left为空...
        root = root->left;
        while (root && root->right) {
            root = root->right;
        }
        return root;
    }

问题!!!

根据上述思想我写下了如下代码:


class Solution {
public:
    TreeNode* successor(TreeNode* root){
        root = root->right;
        while (root&&root->left) {              //如果root->right为空,返回NULL,否则返回他的后继节点
            root = root->left;
        }
        return root;
    }

    TreeNode* predecessor(TreeNode* root) {     //如果root->left为空...
        root = root->left;
        while (root && root->right) {
            root = root->right;
        }
        return root;
    }

    TreeNode* deleteNode(TreeNode *root, int key) {
        if (!root)   return NULL;
        else if (root->val > key) deleteNode(root->left, key);
        else if (root->val < key) deleteNode(root->right, key);
        else {
            if (!root->left && !root->right)   delete root;
            else if (!root->left && root->right) {          //左为空,右不为空
                TreeNode* temp;
                temp=successor(root);
                root->val = temp->val;
                delete temp;
            }
            else if (!root->right && root->left) {          //左不为空,右为空
                TreeNode* temp;
                temp = predecessor(root);
                root->val = temp->val;
                delete temp;
                temp = NULL;
            }
            else if(root->left&&root->right){              //左不为空,由不为空,也是找后继节点
                TreeNode* temp;
                temp = successor(root);
                root->val = temp->val;
                delete temp;
                temp = NULL;
            }
        }
        return root;
    }

};

但是却出现了问题:heap use after free

表示说我使用了delete之后的空间.......

我寻思着自己也没有在delete之后使用空间啊....直接就return了,怎么就报错了??.....

不得已又看了题解,它的思路其实是赋值完后,变成删除当前root->val,然后deleteNode递归操作,最终找到那个叶子前驱(也可能是后继)节点时,直接令root=NULL,最终返回root.相当于在递归中手动置NULL(而不是一开始找到了前驱或者后序节点,赋值后直接delete)

代码

#include<vector>
#include<queue>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
};



class Solution {
public:
    TreeNode* successor(TreeNode* root){
        root = root->right;
        while (root&&root->left) {              //如果root->right为空,返回NULL,否则返回他的后继节点
            root = root->left;
        }
        return root;
    }

    TreeNode* predecessor(TreeNode* root) {     //如果root->left为空...
        root = root->left;
        while (root && root->right) {
            root = root->right;
        }
        return root;
    }

    TreeNode* deleteNode(TreeNode *root, int key) {
        if (!root)   return NULL;
        else if (root->val > key) root->left=deleteNode(root->left, key);
        else if (root->val < key) root->right=deleteNode(root->right, key);
        else {
            if (!root->left && !root->right)   root=NULL;
            else if ( root->right) {          //左为空,右不为空,或者左右都不为空
                TreeNode* temp;
                temp=successor(root);
                root->val = temp->val;
                root->right = deleteNode(root->right, root->val);
            }
            else if (root->left) {          //左不为空,右为空
                TreeNode* temp;
                temp = predecessor(root);
                root->val = temp->val;    
                root->left = deleteNode(root->left, root->val);
            }
        }
        return root;
    }
};