「这是我参与11月更文挑战的第21天，活动详情查看：2021最后一次更文挑战」

450. 删除二叉搜索树中的节点

题目描述

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

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

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

 

示例 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
输出: []

解析

递归法

/**
 * @brief 递归法
 * 递归三部曲
 *  1、确定递归函数的参数与返回值
 *      TreeNode *deleteNode(TreeNode *root,int key)
 *      参数：节点，要删除节点的值 
 *      返回值：通过返回值来删除节点
 *  2、确定递归的终止条件
 *      遇到空返回，说明没有找到要删除的节点
 *      if(root==NULL) return root;
 *  3、确定单层递归的逻辑（一共5种情况）
 *      - （0）没有找到要删除的节点，遍历到空节点直接返回
 *      - 找到要删除的节点
 *          （1）左右孩子节点都为空，直接删除节点，返回NULL为根节点
 *          （2）左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
 *          （3）左孩子不为空，右孩子为空，删除节点，左孩子补位，返回左孩子为根节点
 *          （4）左右孩子都不为空，将删除节点的左孩子放到待删除节点右子树的最左面节点的左孩子上，要删除节点的右孩子作为新的根节点
 */

代码

class Solution
{
public:
    TreeNode *deleteNode(TreeNode *root, int key)
    {
        // 第一种情况，没有找到要删除的节点，返回空
        if (root == nullptr)
        {
            return root;
        }

        if (root->val == key)
        {
            // 第二种情况
            if (root->left == nullptr && root->right == nullptr)
            {
                // 删除节点，释放内存
                delete root;
                return nullptr;
            }

            // 第三种情况，左孩子为空，右孩子不为空，右孩子补位，返回右孩子作为根节点
            else if (root->left == nullptr)
            {
                TreeNode *node = root->right;
                delete root;
                return node;
            }
            // 第四种情况，右孩子为空，左孩子不为空，左孩子补位，返回左孩子作为根节点
            else if (root->right == nullptr)
            {
                TreeNode *node = root->left;
                delete root;
                return node;
            }
            // 第五种情况，左右孩子节点都不为空，
            // 将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置上
            // 返回删除节点的右孩子作为新的根节点

            else
            {
                // 找到右子树最左面的叶子节点
                TreeNode *cur = root->right;

                while (cur->left != nullptr)
                {
                    cur = cur->left;
                }
                // 将带删除节点的左子树放在右子树最左面的叶子节点上
                cur->left = root->left;
                // 保存root节点，进行删除
                TreeNode *tmp = root;
                // 返回待删除节点的右孩子作为新的根节点
                root = root->right;
                delete tmp;
                return root;
            }
        }
        
        // 向左遍历
        if (root->val > key)
        {
            root->left = deleteNode(root->left, key);
        }
        
        // 向右遍历
        if (root->val < key)
        {
            root->right = deleteNode(root->right, key);
        }

        return root;
    }
};

迭代法

/**
 * @brief 迭代法
 * 因为二叉搜索树节点有序，所以不需要使用栈来模拟递归过程
 * 
 * 剪枝需要分为三步：
 *  1、将 root 移动到 [low,high]范围内
 *  2、剪枝左子树
 *  3、剪枝右子树
 * 
 */

代码

class Solution
{
public:
    TreeNode *trimBST(TreeNode *root, int low, int high)
    {
        if (root == nullptr)
        {
            return root;
        }

        // 处理头结点，让root移动到 [low , high]区间内
        while (root != nullptr && (root->val < low || root->val > high))
        {
            // 小于 low值，右移
            if (root->val < low)
            {
                root = root->right;
            }
            // 大于 high值，左移
            else
            {
                root = root->left;
            }
        }

        // 找到处于 [low,high]区间的头结点
        TreeNode *cur = root;

        // 遍历头结点的左子树
        while (cur != nullptr)
        {
            while (cur->left && cur->left->val < low)
            {
                cur->left = cur->left->right;
            }
            cur = cur->left;
        }

        cur = root;

        // 遍历头结点的右子树
        while (cur != nullptr)
        {
            while (cur->right && cur->right->val > high)
            {
                cur->right = cur->right->left;
            }
            cur = cur->right;
        }
        // 返回头结点
        return root;
    }
};