【LeetCode】450. 删除二叉搜索树中的节点（中等）——代码随想录算法训练营Day22

题目链接：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
输出: []

提示:

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

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

文章讲解：代码随想录

视频讲解：调整二叉树的结构最难！| LeetCode：450.删除二叉搜索树中的节点_哔哩哔哩_bilibili

题解1：递归法

思路：删除二叉搜索树的节点要比添加节点更难，因为删除节点的过程中有时会改变二叉树的结构。自顶向下遍历二叉树，具体有以下6种情况：

• (1) 当前节点为空，即没有找到要删除的节点，直接返回 null；
• (2) 当前节点为要删除的节点且为叶子节点，直接返回 null；
• (3) 当前节为要删除的节点且左孩子为空，右孩子不为空，返回右孩子；
• (4) 当前节为要删除的节点且左孩子不为空，有孩子为空，返回左孩子；
• (5) 当前节点为要删除的节点且左右孩子均不为空，将右孩子插入到左子树中，返回左孩子；
• (6) 当前节点不是要删除的节点，向下继续递归。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} key
 * @return {TreeNode}
 */
var deleteNode = function(root, key) {
    if (!root) {
        return null; // 1 当前节点为空，即没有找到要删除的节点，直接返回 null
    }
    // 6 当前节点不是要删除的节点，向下继续递归
    if (root.val > key) {
        root.left = deleteNode(root.left, key);
        return root;
    } else if (root.val < key) {
        root.right = deleteNode(root.right, key);
        return root;
    }
    if (!root.left && !root.right) {
        return null; // 2 当前节点为要删除的节点且为叶子节点，直接返回 null
    }
    if (!root.left) {
        return root.right; // 3 当前节为要删除的节点且左孩子为空，右孩子不为空，返回右孩子
    }
    if (!root.right) {
        return root.left; // 4 当前节为要删除的节点且左孩子不为空，有孩子为空，返回左孩子
    }
    // 5 当前节点为要删除的节点且左右孩子均不为空，将右孩子插入到左子树中，返回左孩子
    let cur = root.left;
    while (cur.right) {
        cur = cur.right;
    }
    cur.right = root.right;
    return root.left;
};

分析：时间复杂度为 O(logn)，空间复杂度为 O(logn)。

题解2：迭代法

思路：使用二叉搜索树的迭代法，具体处理类似递归法。

• 没找到要删除的节点，返回根节点。
• 要删除的节点是根节点，则返回删除根节点后的新的二叉树的根节点；
• 要删除的节点不是根节点，需要判断这个节点是其父节点的左孩子还是右孩子，删除后进行连接操作；
• 删除某个节点的具体操作方法中，将其右孩子插入到左子树中，然后返回左孩子。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} key
 * @return {TreeNode}
 */
var deleteNode = function(root, key) {
    const deleteOneNode = function (node) {
        if (!node) {
            return null;
        }
        if (!node.left) {
            return node.right; // 如果目标节点的左孩子为空，则返回右孩子
        }
        // 左孩子不为空，则把右孩子插入到左孩子的子树中，然后返回左孩子
        let cur = node.left;
        while (cur.right) {
            cur = cur.right;
        }
        cur.right = node.right;
        return node.left;
    };
    let node = root, pre = null;
    // 寻找要删除的节点
    while (node) {
        if (node.val > key) {
            pre = node;
            node = node.left;
        } else if (node.val < key) {
            pre = node;
            node = node.right;
        } else {
            break;
        }
    }
    if (!node) {
        return root; // 如果没找到要删除的节点，返回根节点
    }
    if (!pre) {
        return deleteOneNode(node); // 要删除的节点为根节点，直接返回删除根节点后的二叉树
    }
    if (node.val < pre.val) {
        pre.left = deleteOneNode(node); // 删除的是 pre 的左孩子，将 pre 的左孩子设置为删除左孩子后的子树
    } else {
        pre.right = deleteOneNode(node); // 删除的是 pre 的左孩子，将 pre 的左孩子设置为删除左孩子后的子树
    }
    return root; // 返回根节点
};

分析：时间复杂度为 O(logn)，空间复杂度为 O(1)。

收获

学习了二叉搜索树的删除操作，需要处理好多种情况。递归法中需要处理这个节点的左右子树，迭代法中需要处理这个节点是根节点还是左孩子还是右孩子的多种情况。