LeetCode-Closest Binary Search Tree Value II

Given a non-empty binary search tree and a target value, find k values in the BST that are closest to the target.

Note:

Given target value is a floating point.

You may assume k is always valid, that is: k ≤ total nodes.

You are guaranteed to have only one unique set of k values in the BST that are closest to the target.

Follow up:

Assume that the BST is balanced, could you solve it in less than O(n) runtime (where n = total nodes)?

Analysis:

Use inorder traverse, put all predecessors into a stack, for every successor, put all pres that has smaller gap than that successor into resList and then put this successor into resList.

Solution:

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public List<Integer> closestKValues(TreeNode root, double target, int k) {
Stack<Integer> pres = new Stack<Integer>();
LinkedList<Integer> resList = new LinkedList<Integer>();
closestKValuesRecur(root,target,k,pres,resList);
// If not enough in resList, put more pres into resList. This is because successor is too little.
while (resList.size()<k && !pres.empty()){
resList.addFirst(pres.pop());
}
return resList;
}

public void closestKValuesRecur(TreeNode curNode, double target, int k, Stack<Integer> pres, LinkedList<Integer> resList){
if (curNode == null) return;
if (resList.size()==k) return;

// inorder traverse.
closestKValuesRecur(curNode.left,target,k,pres,resList);

// check curNode
if (curNode.val >= target){
while (resList.size()<k && !pres.empty() && target-pres.peek() < curNode.val-target){
resList.addFirst(pres.pop());
}
if (resList.size()<k){
resList.addLast(curNode.val);
} else {
return;
}
} else {
pres.push(curNode.val);
}

closestKValuesRecur(curNode.right,target,k,pres,resList);
}
}