二叉搜索树结点最小距离

给定一个二叉搜索树的根结点 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的差值。
 

注意：

二叉树的大小范围在 2 到 100。
二叉树总是有效的，每个节点的值都是整数，且不重复。
本题与 530：https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析:解法一：对于树，首先想到先序，中序，后序遍历，而此题中一开始想到，我们可以将这颗树变为数组，遍历出来后，由于仅是求所有节点中最小的差，故先排序一次，遍历一遍求最小的差值；
	解法二:依照解法一，我们要的是一个排好序的数组，题目说的是 二叉搜索树，二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。（百度百科），我们可以利用该性质使用中序遍历，在遍历的时候计算出最小差值，需设置一个previous用来存放刚遍历完的上个数字，用min来存放答案！

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class l16_ {
    private static Integer previous=null,min=Integer.MAX_VALUE;
    private static List<Integer> list = new ArrayList();
    public static void main(String[] args) {
        Integer[]nums = new Integer[]{4,2,6,1,3,null,null};
        TreeNode[] treeNodes =new TreeNode[nums.length];
        for(int i=0;i<nums.length;i++){
            treeNodes[i] = new TreeNode();
        }
        for(int i=0;i<nums.length;i++){
            if(i<(nums.length-1)/2){
                treeNodes[i].setLeft(treeNodes[2*i+1]);
                treeNodes[i].setRight(treeNodes[2*i+2]);
                treeNodes[i].setVal(nums[i]);
            }else {
                treeNodes[i].setVal(nums[i]);
            }
        }
        dfs(treeNodes[0]);
        Collections.sort(list);
        int ans=Integer.MAX_VALUE;
        for(int i=0;i<list.size()-1;i++){
            ans = Math.min(ans,list.get(i+1)-list.get(i));
//            System.out.println(list.get(i));
        }
        System.out.println(ans);
        dfs2(treeNodes[0]);
        System.out.println(min);
    }



    private static void dfs(TreeNode node) {//解法1
        if(node!=null){
            if(node.val!=null){
                list.add(node.val);
            }
            dfs(node.left);
            dfs(node.right);
        }
    }
    private static void dfs2(TreeNode node){//解法2
        if(node==null||(node.val==null)){
            return;
        }
        dfs2(node.left);
        if(previous!=null){
            min = Math.min(min,Math.abs(previous-node.val));
        }
        previous = node.val;
        dfs2(node.right);
    }

}
class TreeNode{
    Integer val;
    TreeNode left;
    TreeNode right;
    TreeNode(Integer x){val=x;}
    TreeNode(Integer x,TreeNode left,TreeNode right){
        this.val=x;
        this.left=left;
        this.right=right;
    }

    public TreeNode() {
    }

    public Integer getVal() {
        return val;
    }

    public void setVal(Integer val) {
        this.val = val;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}

总结：要审题+打好基础，二叉搜索树的性质，各种遍历的写法！