给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
    示例 1：
    783. 二叉搜索树节点最小距离 - 图1

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

    示例 2：
    783. 二叉搜索树节点最小距离 - 图2

    1. 输入：root = [1,0,48,null,null,12,49]
    2. 输出：1
    1. /**
    2.  * Definition for a binary tree node.
    3.  * public class TreeNode {
    4.  *     int val;
    5.  *     TreeNode left;
    6.  *     TreeNode right;
    7.  *     TreeNode() {}
    8.  *     TreeNode(int val) { this.val = val; }
    9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
    10.  *         this.val = val;
    11.  *         this.left = left;
    12.  *         this.right = right;
    13.  *     }
    14.  * }
    15.  */

    题解1：四不像
    二叉树几种遍历方式的特点都已经忘干净了，也没有想到中序遍历实际上就是从小到大把搜索树上的元素依次过一遍。用了返回值的方式，每次将结点最左边的子孙和最右边的子孙返回给父节点，这样一来父节点就可以得知左边的数和右边的数是几了。但实际上没必要这么麻烦。

    1. class Solution {
    2.     int min=1000000;
    3.     int current;
    4.     public int minDiffInBST(TreeNode root) {
    5.         get(root);
    6.         return min;
    7.     }
    8.     public int[] get(TreeNode node){
    9.         int [] res = new int[2];
    10.         int [] left=null, right=null;
    11.         if(node.left!=null){
    12.             left = get(node.left);
    13.             min = Math.min(node.val-left[1], min);
    14.         }
    15.         if(node.right!=null){
    16.             right = get(node.right);
    17.             min = Math.min(right[0]-node.val, min);
    18.         }
    19.         if(left!=null)
    20.             res[0] = left[0];
    21.         else
    22.             res[0] = node.val;
    23.         if(right!=null)
    24.             res[1] = right[1];
    25.         else
    26.             res[1] = node.val;
    27.         return res;
    28.     }
    29. }

    题解2：中序遍历

    class Solution {
    int pre;
    int ans;

    public int minDiffInBST(TreeNode root) {
        ans = Integer.MAX_VALUE;
        pre = -1;
        dfs(root);
        return ans;
    }

    public void dfs(TreeNode root) {
        if (root == null) {
            return;
        }
        dfs(root.left);
        if (pre == -1) {
            pre = root.val;
        } else {
            ans = Math.min(ans, root.val - pre);
            pre = root.val;
        }
        dfs(root.right);
    }
}