leetcode 530 二叉搜索树的最小绝对差

题目

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

示例

输入：root = [4,2,6,1,3]
输出：1

解析

首先题目给了是二叉搜索树，所以一定是有序的，中序遍历就是从小到大，于是乎，可以先中序遍历，生成一个有序数组，再处理这个数组（额外空间）：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func getMinimumDifference(root *TreeNode) int {
    //中序遍历，生成一个额外的有序数组，再两两比较得到最小值
    var res []int
    traversal(root, &res)
    min := 10000  //忘了最大值怎么定义了，先这样写
    for i:=1; i < len(res); i++ {
        tmp := res[i] - res[i-1]
        fmt.Print(tmp)
        if tmp < min {
            min = tmp 
        }
    }
    return min
}

func traversal(root *TreeNode, res *[]int) {
    if root == nil {
        return 
    }
    traversal(root.Left, res)
    *res = append(*res, root.Val)
    traversal(root.Right, res)
}

注意递归函数中，传了res的指针，定义再函数里，然后返回是不行的，会不断被重复初始化；
下面这个方法中，是不使用额外空间，而是保存前一个指针的值（代码理论上感觉是对的，但没有跑全示例）：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func getMinimumDifference(root *TreeNode) int {
    //中序遍历，生成一个额外的有序数组，再两两比较得到最小值
    var prev *TreeNode //保留前一个节点的指针
    min := math.MaxInt
    traversal(root, &min, prev)

    return min
}

func traversal(root *TreeNode, min *int, prev *TreeNode) {
    if root == nil {
        return 
    }
    traversal(root.Left, min, prev)
    if prev != nil && root.Val - prev.Val < *min {
        *min = root.Val - prev.Val
    }
    prev = root
    traversal(root.Right, min, prev)
}

但这么写就是对的，离谱：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func getMinimumDifference(root *TreeNode) int {
    //中序遍历，生成一个额外的有序数组，再两两比较得到最小值
    var prev *TreeNode //保留前一个节点的指针
    min := math.MaxInt
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode) {
        if node == nil {
            return 
        }
        traversal(node.Left)
        if prev != nil && node.Val - prev.Val < min {
            min = node.Val - prev.Val
        }
        prev = node
        traversal(node.Right)
    }
    traversal(root)
    return min
}

---

然后就是迭代法。迭代法还是抄中序遍历的套路：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func getMinimumDifference(root *TreeNode) int {
    if root == nil {
        return 0 
    }
    min := math.MaxInt
    var prev *TreeNode //保留前一个节点的指针
    stack := list.New()
    cur := root
    for cur != nil || stack.Len() > 0 {
        if cur != nil {
            stack.PushBack(cur)
            cur = cur.Left
        } else {
            cur = stack.Remove(stack.Back()).(*TreeNode)
            if prev != nil && cur.Val - prev.Val < min {
                min = cur.Val - prev.Val
            }
            prev = cur
            cur = cur.Right
        }
    }
    return min
}