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;
}
}