[Swift]LeetCode450. 删除二叉搜索树中的节点 | Delete Node in a BST

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10341750.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.

Basically, the deletion can be divided into two stages:

1. Search for a node to remove.
2. If the node is found, delete the node. 

Note: Time complexity should be O(height of tree).

Example:

root = [5,3,6,2,4,null,7]
key = 3

    5
   / \
  3   6
 / \   \
2   4   7

Given key to delete is 3. So we find the node with value 3 and delete it.

One valid answer is [5,4,6,2,null,null,7], shown in the following BST.

    5
   / \
  4   6
 /     \
2       7

Another valid answer is [5,2,6,null,4,null,7].

    5
   / \
  2   6
   \   \
    4   7

---

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

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

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

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

示例:

root = [5,3,6,2,4,null,7]
key = 3

    5
   / \
  3   6
 / \   \
2   4   7

给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。

一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。

    5
   / \
  4   6
 /     \
2       7

另一个正确答案是 [5,2,6,null,4,null,7]。

    5
   / \
  2   6
   \   \
    4   7

---

152ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func deleteNode(_ root: TreeNode?, _ key: Int) -> TreeNode? {
        /*
         *  思路:
         *  1,找到需要被删除的节点
         *  2,没有子节点,直接删除
         *  3,一个子节点,直接替换
         *  4,两个子节点,中序遍历的第一个节点替换,BST的中序遍历就是排好序的
         */
        if root == nil {return root}
        var temp = root
        // 在左子树中寻找删除
        if temp!.val > key{
        
            temp?.left = deleteNode(temp?.left, key)
        }else if temp!.val < key{
            // 在右子树中删除
            temp?.right = deleteNode(temp?.right, key)
        }else{
            // 找到了需要删除的节点,如果节点有一个子节点
            if temp?.left == nil || temp?.right == nil{
                temp = temp?.left == nil ? temp?.right : temp?.left
            }else{
                var node = temp!.right!
                while node.left != nil{
                    node = node.left!
                }
                temp!.val = node.val
                temp?.right = deleteNode(temp?.right, node.val)
            }
        }
        return temp
    }
}

---

 164ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func deleteNode(_ root: TreeNode?, _ key: Int) -> TreeNode? {
        guard let root = root else {
            return nil
        }
        
        if key < root.val {
            root.left = deleteNode(root.left, key)
        } else if key > root.val {
            root.right = deleteNode(root.right, key)
        } else {
            if root.left == nil {
                return root.right
            } else if root.right == nil {
                return root.left
            } else {
                let minNode = findMin(root.right!)
                root.val = minNode.val
                root.right = deleteNode(root.right, root.val)
            }
        }
        
        return root
    }
    
    func findMin(_ root: TreeNode) -> TreeNode {
        var root = root
        
        while let leftNode = root.left {
            root = leftNode
        }
        
        return root
    }
}

---

184ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func deleteNode(_ root: TreeNode?, _ key: Int) -> TreeNode? {
        var root = root
        if root == nil {return nil}
        if root!.val == key
        {
            if root!.right == nil {return root!.left}
            else
            {
                var cur:TreeNode? = root!.right
                while(cur?.left != nil)
                {
                    cur = cur!.left          
                }
                (root!.val,cur!.val) = (cur!.val,root!.val) 
            }
        }
        root!.left = deleteNode(root!.left, key)
        root!.right = deleteNode(root!.right, key)
        return root
    }
}