[Swift]LeetCode783. 二叉搜索树结点最小距离 | Minimum Distance Between BST Nodes

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

Given a Binary Search Tree (BST) with the root node root, return the minimum difference between the values of any two different nodes in the tree.

Example :

Input: root = [4,2,6,1,3,null,null]
Output: 1
Explanation:
Note that root is a TreeNode object, not an array.

The given tree [4,2,6,1,3,null,null] is represented by the following diagram:

          4
        /   
      2      6
     /     
    1   3  

while the minimum difference in this tree is 1, it occurs between node 1 and node 2, also between node 3 and node 2.

Note:

1. The size of the BST will be between 2 and 100.
2. The BST is always valid, each node's value is an integer, and each node's value is different.

---

给定一个二叉搜索树的根结点 root, 返回树中任意两节点的差的最小值。

示例：

输入: root = [4,2,6,1,3,null,null]
输出: 1
解释:
注意，root是树结点对象(TreeNode object)，而不是数组。

给定的树 [4,2,6,1,3,null,null] 可表示为下图:

          4
        /   
      2      6
     /     
    1   3  

最小的差值是 1, 它是节点1和节点2的差值, 也是节点3和节点2的差值。

注意：

1. 二叉树的大小范围在 2 到 100。
2. 二叉树总是有效的，每个节点的值都是整数，且不重复。

---

Runtime: 12 ms

Memory Usage: 19 MB

/**
 * 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 minDiffInBST(_ root: TreeNode?) -> Int {
        var res:Int = Int.max
        helper(root, Int.min, Int.max, &res)
        return res
    }
    
    func helper(_ node: TreeNode?,_ low:Int,_ high:Int,_ res:inout Int)
    {
        if node == nil {return}
        if low != Int.min {res = min(res, node!.val - low)}
        if high != Int.max {res = min(res, high - node!.val)}
        helper(node?.left, low, node!.val, &res);
        helper(node?.right, node!.val, high, &res);        
    }
}

---

12ms

/**
 * 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 minDiffInBST(_ root: TreeNode?) -> Int {
        guard let node = root else {
            return 0
        }
        var res = Int.max
        var pre: Int?
        
        func minD(_ r: TreeNode) {
            if let left = r.left {
                minD(left)
            }
            if let num = pre {
                res = min(res, r.val - num)
            }
            pre = r.val
            if let right = r.right {
                minD(right)
            }
        }
        
        minD(node)
        return res
    }
}

---

16ms

class Solution {
    func midOrder(_ root: TreeNode?) -> [Int] {
        guard root != nil else {
            return []
        }
        return midOrder(root!.left) + [root!.val] + midOrder(root!.right)
    }
    
    func minDiffInBST(_ root: TreeNode?) -> Int {
        var minDiff: Int?
        var lhs: Int?
        for i in midOrder(root) {
            if lhs != nil {
                if minDiff == nil {
                    minDiff = abs(lhs! - i)
                } else {
                    minDiff = min(minDiff!, abs(lhs! - i))
                }
            }
            lhs = i
        }
        return minDiff ?? 0
    }
}

---

24ms

/**
 * 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 minDiffInBST(_ root: TreeNode?) -> Int 
    {
        guard let root = root else { return 0 }
        var sum = root.val
        var nodes = [root]
        
        while !nodes.isEmpty
        {
            var temp = [TreeNode]()
            for i in 0...nodes.count-1
            {
                let root = nodes.removeFirst()
                if let left = root.left
                {
                    temp.append(left)
                }
                
                if let right = root.right
                {
                    temp.append(right)
                }
                compare(root, root.val, &sum)
            }
            nodes = temp
        }
        
        return sum
    }
    
    func compare(_ root: TreeNode?, _ target: Int, _ sum: inout Int)
    {
        guard let root = root else { return }
        let left = root.left
        let right = root.right
        if let left = left
        {
            sum = min(abs(target-left.val), sum)
        }
        
        if let right = right
        {
            sum = min(abs(target-right.val), sum)
        }
        
        if left != nil && right != nil
        {
            sum = min(abs(left!.val-right!.val), sum)
        }
        
        compare(root.left, target, &sum )
        compare(root.right, target, &sum)
    }
}