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.

 

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

 

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public IList<int> ClosestKValues(TreeNode root, double target, int k) {
        var result = new List<int>();
        
        Stack<int> s1 = new Stack<int>(), s2 = new Stack<int>();
        Inorder(root, target, true, s1);
        Inorder(root, target, false, s2);
        
        for (int i = 0; i < k; i++)
        {
            if (s1.Count == 0)
            {
                result.Add(s2.Pop());
            }
            else if (s2.Count == 0)
            {
                result.Add(s1.Pop());
            }
            else
            {
                double d1 = Math.Abs((double)s1.Peek() - target);
                double d2 = Math.Abs((double)s2.Peek() - target);
                
                if (d1 < d2)
                {
                    result.Add(s1.Pop());
                }
                else
                {
                    result.Add(s2.Pop());
                }
            }
        }
        
        return result;
    }
    
    
    private void Inorder(TreeNode node, double target, bool reverse, Stack<int> stack)
    {
        if (node == null) return;
        
        Inorder(reverse ? node.right : node.left, target, reverse, stack);
        
        if (reverse ? (double)node.val <= target : (double)node.val > target)
        {
            return;
        }
        
        stack.Push(node.val);
        
        Inorder(reverse ? node.left : node.right, target, reverse, stack);
    }
}