leetcode 530. Minimum Absolute Difference in BST

Given a binary search tree with non-negative values, find the minimum absolute difference between values of any two nodes.

Example:

Input:

   1
    \
     3
    /
   2

Output:
1

Explanation:
The minimum absolute difference is 1, which is the difference between 2 and 1 (or between 2 and 3).

Note: There are at least two nodes in this BST.

考虑到是BST，那么A的左结点值一定比A小，A的右结点值一定比A大。那么如果A有左结点B，左结点B有右结点C，那么|A-C|一定小于|A-B|。本以为我的方法时间复杂度不咋地，结果却是beat了80%+的java submissions.

package leetcode;

public class Minimum_Absolute_Difference_in_BST_530 {

	int min=Integer.MAX_VALUE;
	
	public int getMinimumDifference(TreeNode root) {	
		if(root.left!=null){
			TreeNode leftNode=root.left;
			int theSub=0;
			if(leftNode.right!=null){
				theSub=root.val-findMostRight(leftNode);
			}
			else{
				theSub=root.val-leftNode.val;
			}
			min=min<theSub?min:theSub;
			theSub=getMinimumDifference(root.left);
			min=min<theSub?min:theSub;
		}
		if(root.right!=null){
			TreeNode rightNode=root.right;
			int theSub=0;
			if(rightNode.left!=null){
				theSub=findMostLeft(rightNode)-root.val;
			}
			else{
				theSub=rightNode.val-root.val;
			}
			min=min<theSub?min:theSub;
			theSub=getMinimumDifference(root.right);
			min=min<theSub?min:theSub;
		}
		return min;
	}
	
	public int findMostRight(TreeNode it){
		while(it.right!=null){
			it=it.right;
		}
		return it.val;
	}
	
	public int findMostLeft(TreeNode it){
		while(it.left!=null){
			it=it.left;
		}
		return it.val;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Minimum_Absolute_Difference_in_BST_530 m=new Minimum_Absolute_Difference_in_BST_530();
		TreeNode root=new TreeNode(236);
		root.left=new TreeNode(104);
		root.right=new TreeNode(701);
		root.left.right=new TreeNode(227);
		root.right.right=new TreeNode(911);
		System.out.println(m.getMinimumDifference(root));
	}

}

大神的解法是多种多样的。

解法一：利用中根遍历。（ time complexity O(N), space complexity O(1)）因为对于一个BST（二叉排序树），它的中根遍历结果是从小到大排序的，比如：
                1
                  \
                   4
                 /
               3
             /
          2
中根遍历的结果就是1 2 3 4，因为是从小到大排序，所以minimum absolute difference一定是发生在中根遍历的相邻节点上的。
Since this is a BST, the inorder traversal of its nodes results in a sorted list of values. Thus, the minimum absolute difference must occur in any adjacently traversed nodes. I use the global variable "prev" to keep track of each node's inorder predecessor.

public class Solution {
    
    int minDiff = Integer.MAX_VALUE;
    TreeNode prev;
    
    public int getMinimumDifference(TreeNode root) {
        inorder(root);
        return minDiff;
    }
    
    public void inorder(TreeNode root) {
        if (root == null) return;
        inorder(root.left);
        if (prev != null) minDiff = Math.min(minDiff, root.val - prev.val);
        prev = root;
        inorder(root.right);
    }

}

解法二：利用TreeSet中的floor和ceiling方法：
TreeSet是有序的Set集合，因此支持add、remove、get等方法。lower、floor、ceiling 和 higher 分别返回小于、小于等于、大于等于、大于给定元素的元素，如果不存在这样的元素，则返回 null。
What if it is not a BST? (Follow up of the problem) The idea is to put values in a TreeSet and then every time we can use O(lgN) time to lookup for the nearest values.
Solution 2 - Pre-Order traverse, time complexity O(NlgN), space complexity O(N).

public class Solution {
    TreeSet<Integer> set = new TreeSet<>();
    int min = Integer.MAX_VALUE;
    
    public int getMinimumDifference(TreeNode root) {
        if (root == null) return min;
        
        if (!set.isEmpty()) {
            if (set.floor(root.val) != null) {
                min = Math.min(min, root.val - set.floor(root.val));
            }
            if (set.ceiling(root.val) != null) {
                min = Math.min(min, set.ceiling(root.val) - root.val);
            }
        }
        
        set.add(root.val);
        
        getMinimumDifference(root.left);
        getMinimumDifference(root.right);
        
        return min;
    }
}