783. Minimum Distance Between BST Nodes

Given a Binary Search Tree (BST) with the root node root, return the minimum difference between the values of any two different nodes in the tree.

Example :

Input: root = [4,2,6,1,3,null,null]
Output: 1
Explanation:
Note that root is a TreeNode object, not an array.

The given tree [4,2,6,1,3,null,null] is represented by the following diagram:

          4
        /   \
      2      6
     / \    
    1   3  

while the minimum difference in this tree is 1, it occurs between node 1 and node 2, also between node 3 and node 2.

Note:

1. The size of the BST will be between 2 and 100.
2. The BST is always valid, each node’s value is an integer, and each node’s value is different.

题目给出一棵二叉树，找到节点间的最小差值。可以使用中序遍历，得到【1、2、3、4、6】，然后遍历找到相邻节点的最小差值

中序遍历的非递归代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int minDiffInBST(TreeNode root) {        
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new LinkedList<>();
        while(root != null || !stack.isEmpty()) {
            while(root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            list.add(root.val);
            root = root.right;
        }
        int minDiff = Integer.MAX_VALUE;
        for(int i = 0; i < list.size() - 1; i++) {
            minDiff = Math.min(minDiff, list.get(i+1)-list.get(i));
        }
        return minDiff;
    }
}

上面代码的耗时如下：

由于代码运行的耗时很长，所以我决定做一些优化

将

for(int i = 0; i < list.size() - 1; i++) {
    minDiff = Math.min(minDiff, list.get(i+1)-list.get(i));
}

替换成

while(list.size() > 1) {
    Integer pre = list.removeFirst();
    minDiff = Math.min(minDiff, list.getFirst()-pre);
}    

耗时减少了一些。

中序遍历的递归代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    private List<Integer> list = new LinkedList<>();

    public int minDiffInBST(TreeNode root) {
        inOrder(root);
        int minDiff = Integer.MAX_VALUE;
        for(int i = 0; i < list.size() - 1; i++) {
            minDiff = Math.min(minDiff, list.get(i+1) - list.get(i+1));
        }
        return minDiff;
    }

    public void inOrder(TreeNode root) {
        if(root != null) {
            if(root.left != null) {                
                inOrder(root.left);
            }
            list.add(root.val);
            if(root.right != null) {                
                inOrder(root.right);
            }
        }
    }
}

上面代码的耗时如下：

另一种简洁的写法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {      
    Integer minDiff = Integer.MAX_VALUE, pre = null;    

    public int minDiffInBST(TreeNode root) {                
        if(root != null) {
            if(root.left != null) {                
                minDiffInBST(root.left);
            }
            if(pre != null) {
                minDiff = Math.min(minDiff, root.val - pre);
            }
            pre = root.val;
            if(root.right != null) {                
                minDiffInBST(root.right);
            }
        }  
        return minDiff;
    }

}

树的中序遍历参考：
https://blog.csdn.net/u010429424/article/details/77778254