272. 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)?

Hint:

1. Consider implement these two helper functions:
   1. getPredecessor(N), which returns the next smaller node to N.
   2. getSuccessor(N), which returns the next larger node to N.

本题还是比较难的，先说常规方法，首先把树分成两部分，一个是小于target的，一个是大于等于target的，然后进行比较，找出k个接近target的k个值，代码如下：

/**
 * 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) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<Integer> s1 = new Stack<Integer>();
        Stack<Integer> s2 = new Stack<Integer>();
        Inorder(s1,false,root,target);
        Inorder(s2,true,root,target);
        while(k-->0){
            if(s1.isEmpty()){
                res.add(s2.pop());
            }else if(s2.isEmpty()){
                res.add(s1.pop());
            }else if(Math.abs(s1.peek()-target)<Math.abs(s2.peek()-target)){
                res.add(s1.pop());
            }else{
                res.add(s2.pop());
            }
        }
        return res;
    }
    public void Inorder(Stack<Integer> s,boolean reverse,TreeNode root,double target){
        if(root==null) return;
        Inorder(s,reverse,reverse?root.left:root.right,target);
        if((reverse&&(root.val>target))||(!reverse&&(root.val<=target))) return;
        s.push(root.val);
        Inorder(s,reverse,reverse?root.right:root.left,target);
    }
}

 然而此方法的时间复杂度并没有减少，时间复杂度为O（n+k），所以有了动态的优化方法：

思路是，创建四个方法，分别有两个初始化，两个获取下一个方法。初始化的作用是找到target最近的较大和较小TreeNode，同时如果在过程中的也满足条件，把其放入stack中。获取下一个方法是，获取后，转其对应的另外子树，同时遍历一个h，代码如下：

/**
 * 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) {
        List<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> succ = new Stack<TreeNode>();
        Stack<TreeNode> pre = new Stack<TreeNode>();
        initalizesucc(root,target,succ);
        initalizepre(root,target,pre);
        if(!succ.isEmpty()&&!pre.isEmpty()&&succ.peek().val==pre.peek().val){
            getNextpre(pre);
        }
        while(k-->0){
            if(succ.isEmpty()){
               res.add(getNextpre(pre)); 
            }else if(pre.isEmpty()){
                res.add(getNextsucc(succ));
            }else{
                double succ_diff = Math.abs((double)succ.peek().val-target);
                double pre_diff = Math.abs((double)pre.peek().val-target);
                if(succ_diff<pre_diff){
                    res.add(getNextsucc(succ));
                }else{
                    res.add(getNextpre(pre));
                }
            }
        }
        return res;
    }
    public void initalizesucc(TreeNode root,double target,Stack<TreeNode> succ){
        while(root!=null){
            if(root.val==target){
                succ.push(root);
                break;
            }else if(root.val<target){
                root = root.right;
            }else{
                succ.push(root);
                root = root.left;
            }
        }
    }
    public void initalizepre(TreeNode root,double target,Stack<TreeNode> pre){
        while(root!=null){
            if(root.val==target){
                pre.push(root);
                break;
            }else if(root.val<target){
                pre.push(root);
                root = root.right;
            }else{
                root = root.left;
            }
        }
    }
    public int getNextsucc(Stack<TreeNode> stack){
        TreeNode succ = stack.pop();
        int val = succ.val;
        succ = succ.right;
        while(succ!=null){
            stack.push(succ);
            succ = succ.left;
        }
        return val;
    }
    public int getNextpre(Stack<TreeNode> stack){
        TreeNode pre = stack.pop();
        int val = pre.val;
        pre = pre.left;
        while(pre!=null){
            stack.push(pre);
            pre = pre.right;
        }
        return val;
    }
}