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