[LeetCode] 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.

Example:

Input: root = [4,2,5,1,3], target = 3.714286, and k = 2

    4
   / \
  2   5
 / \
1   3

Output: [4,3]

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

最接近的二叉搜索树的值版本二。版本一在此。题意是给一个二叉树，一个浮点数target和一个K，请返回二叉树中val最接近target的K个节点的值。

discussion里面的最高票答案是用两个stack做，一个存储target之前所有的前驱节点，一个存储所有的后驱节点，判断栈顶元素与target差值谁更接近而决定从哪个栈弹出元素加到结果集。我个人觉得这个解法的代码实现起来不是很轻松，我这里给出的是deque双端队列的解法。思路是用中序遍历先得到整棵树的节点，会是一个升序的数组；接着把这个数组放进一个双端队列，之后判断队首和队尾的元素谁跟target的差值更大，而决定将哪个元素弹出队列；终止条件是队列元素不能小于K。

时间O(n)

空间O(n)

Java实现

class Solution {
    public List<Integer> closestKValues(TreeNode root, double target, int k) {
        // Deque<Integer> dq = new ArrayDeque<>();
        Deque<Integer> dq = new LinkedList<>();
        inorder(root, dq);
        while (dq.size() > k) {
            if (Math.abs(dq.peekFirst() - target) > Math.abs(dq.peekLast() - target)) {
                dq.pollFirst();
            } else {
                dq.pollLast();
            }
        }
        return new ArrayList<Integer>(dq);
    }

    public void inorder(TreeNode root, Deque<Integer> dq) {
        if (root == null) {
            return;
        }
        inorder(root.left, dq);
        dq.add(root.val);
        inorder(root.right, dq);
    }
}

 

JavaScript实现

/**
 * @param {TreeNode} root
 * @param {number} target
 * @param {number} k
 * @return {number[]}
 */
var closestKValues = function (root, target, k) {
    var helper = function (root, dq) {
        if (root == null) {
            return;
        }
        helper(root.left, dq);
        dq.push(root.val);
        helper(root.right, dq);
    }
    let dq = [];
    helper(root, dq);
    while (dq.length > k) {
        if (Math.abs(dq[0] - target) > Math.abs(dq[dq.length - 1] - target)) {
            dq.shift();
        } else {
            dq.pop();
        }
    }
    return dq;
};

 

LeetCode 题目总结