【算法21天：Day21】第六章二叉树 LeetCode 二叉搜索树的最小绝对差（530）

题目一：

解法一：（递归）

解题思路：先将结点的值遍历到数组中，然后在数组中一一比较，取得两数之差的最小差值（绝对值）

var getMinimumDifference = function(root) {
    let arr = []
    let min = Number.MAX_SAFE_INTEGER
    var preOrder = function(root) {
        if (root === null) return
        arr.push(root.val)
        root.left && preOrder(root.left)
        root.right && preOrder(root.right)
    }
    preOrder(root)
    for (let i = 0; i < arr.length - 1; i++) {
        for(let j = i + 1; j < arr.length; j++) {
            if (Math.abs(arr[i] - arr[j]) < min) {
                min = Math.abs(arr[i] - arr[j])
            }
        }
    }
    return min
};

解法二：（递归 | 优化解法一）

解题思路：题目中要求在二叉搜索树上任意两节点的差的绝对值的最小值。

注意是二叉搜索树，二叉搜索树可是有序的。

遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。

那么二叉搜索树采用中序遍历，其实就是一个有序数组。

在一个有序数组上求两个数最小差值，这是不是就是一道送分题了。

最直观的想法，就是把二叉搜索树转换成有序数组，然后遍历一遍数组，就统计出来最小差值了。

var getMinimumDifference = function(root) {
    let arr = []
    let min = Number.MAX_SAFE_INTEGER
    var preOrder = function(root) {
        if (root === null) return
        root.left && preOrder(root.left)
        arr.push(root.val)
        root.right && preOrder(root.right)
    }
    preOrder(root)
    for (let i = 1; i < arr.length; i++) {
        min = Math.min(min, arr[i] - arr[i - 1])
    }
    return min
};

解法三：（递归 | 优化解法二）

其实在二叉搜素树中序遍历的过程中，我们就可以直接计算了。

需要用一个pre节点记录一下cur节点的前一个节点。

var getMinimumDifference = function(root) {
    let min = Infinity
    let pre = null
    var traversal = function(cur) {
        if (cur === null) return
        traversal(cur.left)
        if (pre !== null) {
            min = Math.min(min, cur.val - pre.val)
        }
        pre = cur
        traversal(cur.right)
    }
    traversal(root)
    return min
};

解法四：（迭代 | 中序遍历）

var getMinimumDifference = function(root) {
    let stack = []
    let cur = root
    let pre = null
    let res = Infinity
    while (cur || stack.length) {
        if (cur) {
            stack.push(cur)
            cur = cur.left
        } else {
            cur = stack.pop()
            if (pre) res = Math.min(res, cur.val - pre.val)
            pre = cur
            cur = cur.right
        }
    }
    return res
};