Cloest Binary Search Tree Value II

/**
 * 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> result = new ArrayList<>();
        if (k == 0 || root == null) {
            return result;
        }
        
        Stack<TreeNode> successor = new Stack<>();
        Stack<TreeNode> precessor = new Stack<>();
        
        initialStack(successor, root, true, target);
        initialStack(precessor, root, false, target);
        
        if(!successor.isEmpty() && !precessor.isEmpty() && successor.peek().val == precessor.peek().val) {
            getNext(precessor, false);
        }
        
        while (result.size() < k) {
            if (successor.isEmpty()) {
                result.add(getNext(precessor, false));
            } else if (precessor.isEmpty()) {
                result.add(getNext(successor, true));
            } else {
                boolean sclose = Math.abs((double) successor.peek().val - target) < Math.abs((double)precessor.peek().val - target);
                if (sclose) {
                    result.add(getNext(successor, true));
                } else {
                    result.add(getNext(precessor, false));
                }
            }
        }
        return result;
    }
    
    private void initialStack(Stack<TreeNode> stack, TreeNode root, boolean successor, double target) {
        while (root != null) {
            if (root.val == target) {
                stack.push(root);
                break;
            } else if (root.val > target == successor) {
                stack.push(root);
                root = successor ? root.left : root.right;
            } else {
                root = successor ? root.right : root.left;
            }
        }
    }
    
    private int getNext(Stack<TreeNode> stack, boolean successor) {
        TreeNode current = stack.pop();
        int result = current.val;
        current = successor ? current.right : current.left;
        while (current != null) {
            stack.push(current);
            current = successor ? current.left : current.right;
        }
        return result;
    }
}