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

题目来源：https://leetcode.cn/problems/delete-node-in-a-bst/

大致题意：
给一个二叉排序树和整数 key，在二叉排序树找到值为 key 的节点删除，删除后要保证二叉排序树的性质不变，返回删除值为 key 节点后（如果没有则不变）的二叉树根节点

---

思路

按照二叉排序树的性质搜索值 key 的节点，找不到的话不用做任何更改，找到的话需要对节点删除，并且需要找该节点的后继节点替换被删除节点

被删除节点的后继节点为：

• 被删除节点是叶子节点，那么后继节点为空
• 被删除节点有一个子节点，那么后继节点即为子节点
• 被删除节点有两个子节点，那么后继节点是被删除节点右子树中的最小节点（也就是右子树中最左侧节点）

找到后继节点后，使用后继节点替换被删除节点，并且，若被删除节点有两个子节点，还需要将后继节点从右子树中删除

代码：

public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null) {
            return null;
        }
        // 当前节点大于 key，去左子树中搜索
        if (root.val > key) {
            root.left = deleteNode(root.left, key);
        } else if (root.val < key) {    // 当前节点小于 key，去右子树中搜索
            root.right = deleteNode(root.right, key);
        } else {    // 当前节点等于 key，找后继节点并返回
            // 当前节点为叶子节点
            if (root.left == null && root.right == null) {
                return null;
            }
            // 当前节点只有一个子节点
            if (root.left == null) {
                return root.right;
            }
            if (root.right == null) {
                return root.left;
            }
            // 当前节点有两个子节点，后继节点为右子树中的最小节点（最左侧节点）
            TreeNode successor = root.right;
            while (successor.left != null) {
                successor = successor.left;
            }
            // 将后继节点从右子树删除
            successor.right = deleteNode(root.right, successor.val);
            successor.left = root.left;
            root = successor;
        }
        return root;
    }

非递归实现

public TreeNode deleteNode_pro(TreeNode root, int key) {
        TreeNode cur = root;
        TreeNode curParent = null;
        // 迭代寻找值为 key 的节点
        while (cur != null && cur.val != key) {
            curParent = cur;
            if (cur.val > key) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        // 没有找到值为对应 key 的节点
        if (cur == null) {
            return root;
        }
        // 找到了对应节点，寻找对应节点的替代节点（后继节点）
        if (cur.left == null && cur.right == null) {    // 对应节点为叶子节点，没有后继节点
            cur = null;
        }
        else if (cur.left == null) {    // 若对应节点只有一个子节点，后继节点为非空子节点
            cur = cur.right;
        } else if (cur.right == null) {
            cur = cur.left;
        } else {    // 对应节点有两个子节点，找出后继节点，并将后继节点从右子树中删除
            TreeNode successor = cur.right;
            TreeNode successorParent = cur;
            while (successor.left != null) {
                successorParent = successor;
                successor = successor.left;
            }
            if (successorParent != cur) {   // 若对应节点右儿子不是后继节点
                successorParent.left = successor.right;
                successor.right = cur.right;
            }
            successor.left = cur.left;
            cur = successor;
        }
        // 更新被删除节点父节点到后继节点的指针
        if (curParent == null) {
            return cur;
        }
        else if (curParent.val > key) {
            curParent.left = cur;
        } else {
            curParent.right = cur;
        }
        return root;
    }