[Swift]LeetCode530. 二叉搜索树的最小绝对差 | Minimum Absolute Difference in BST

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

Given a binary search tree with non-negative values, find the minimum absolute difference between values of any two nodes.

Example:

Input:
   1
    
     3
    /
   2
Output:
1
Explanation:
The minimum absolute difference is 1, which is the difference between 2 and 1 (or between 2 and 3).

 Note: There are at least two nodes in this BST.

---

给定一个所有节点为非负值的二叉搜索树，求树中任意两节点的差的绝对值的最小值。

示例 :

输入:

   1
    
     3
    /
   2
输出:
1
解释:
最小绝对差为1，其中 2 和 1 的差的绝对值为 1（或者 2 和 3）。

注意: 树中至少有2个节点。

---

 44ms

/**
 * 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 {
    private var array = [Int]()
    func getMinimumDifference(_ root: TreeNode?) -> Int {
        inOrder(root)
        
        var minDiff = Int.max
        
        for x in 0..<array.count-1 {
            let diff = array[x+1] - array[x]
            if diff < minDiff {
                minDiff = diff
            }
        }
        
        return minDiff
    }
    
    private func inOrder(_ node: TreeNode?) {
        guard let node = node else { return }
        inOrder(node.left)
        array.append(node.val)
        inOrder(node.right)
    }
}

---

48ms

/**
 * 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 getMinimumDifference(_ root: TreeNode?) -> Int {
        var res = Int.max
        guard let root = root else { return res }
        
        if var left = root.left {
            while left.right != nil {
                left = left.right!
            }    
            let diff = abs(left.val - root.val)
            if res > diff { res = diff }
        }
        
        if var right = root.right {
            while right.left != nil {
                right = right.left!
            }
            let diff = abs(root.val - right.val)
            if res > diff { res = diff }
        }
        
        let minLeft = getMinimumDifference(root.left) 
        if res > minLeft { res = minLeft }
        let minRight = getMinimumDifference(root.right)
        if res > minRight { res = minRight }
        
        return res
    }
}

---

52ms

/**
 * 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 getMinimumDifference(_ root: TreeNode?) -> Int {
        var pre: Int?
        return getMinimumDifference(root, &pre)
    }

    func getMinimumDifference(_ root: TreeNode?, _ val: inout Int?) -> Int {
        guard let root = root else {
            return Int.max
        }

        var result = getMinimumDifference(root.left, &val)
        if let val = val {
            result = min(result, root.val - val)
        }

        val = root.val
        
        result = min(result, getMinimumDifference(root.right, &val))

        return result
    }
    
}

---

64ms

/**
 * 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 getMinimumDifference(_ root: TreeNode?) -> Int {
        var result = Int.max
        var pre: Int?
        let a = getMinimumDifference(root, &pre, &result)
        print(a)
        return result
    }
    
    func getMinimumDifference(_ root: TreeNode?, _ val: inout Int?, _ result: inout Int) -> Int {
        guard let root = root else {
            return result
        }
        
        getMinimumDifference(root.left, &val, &result)
        if let val = val {
            result = min(result, root.val - val)
        }
        
        val = root.val
        getMinimumDifference(root.right, &val, &result)
        
        return result
    }
}

---

92ms

/**
 * 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 getMinimumDifference(_ root: TreeNode?) -> Int {
    var set = Set<Int>.init()
    var queue = [TreeNode]()
    if let node = root {
        queue.append(node)
    }
    while !queue.isEmpty {
        let node = queue.first
        queue.removeFirst()
        set.update(with: node!.val)
        if node!.left != nil {
            queue.append(node!.left!)
        }
        if node!.right != nil {
            queue.append(node!.right!)
        }
    }
    var res = Int.max
    let arr = set.sorted()
    for i in 0..<arr.count-1 {
        if abs(arr[i]-arr[i+1]) < res {
            res = abs(arr[i]-arr[i+1])
        }
    }
    return res
}    
}

---

92ms

/**
 * 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 getMinimumDifference(_ root: TreeNode?) -> Int {
        //中序遍历的递归方法
        var res:Int = Int.max, pre:Int = -1
        inOrder(root,&pre ,&res)
        return res
    }
    func inOrder(_ root: TreeNode?,_ pre: inout Int,_ res: inout Int)
    {
        if root == nil {return}
        inOrder(root!.left,&pre,&res)
        if pre != -1
        {
            res = min(res,root!.val - pre)
        }
        pre = root!.val
        inOrder(root!.right,&pre,&res)
    }
}