Leetcode: Closest Binary Search Tree Value

Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target.

Note:
Given target value is a floating point.
You are guaranteed to have only one unique value in the BST that is closest to the target.

 Inorder Traversal:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int closestValue(TreeNode root, double target) {
        if (root == null) return Integer.MIN_VALUE;
        ArrayList<Integer> preVal = new ArrayList<Integer>();
        ArrayList<Integer> res = new ArrayList<Integer>();
        helper(root, target, preVal, res);
        if (res.size() == 0) {
            res.add(preVal.get(0));
        }
        return res.get(0);
    }
    
    public void helper(TreeNode root, double target, ArrayList<Integer> preVal, ArrayList<Integer> res) {
        if (root == null) return;
        helper(root.left, target, preVal, res);
        if (preVal.size() == 0) {
            preVal.add(root.val);
        }
        else if (root.val >= target) {
            if (res.size()==0)
                res.add(Math.abs((double)(preVal.get(0)-target))<Math.abs((double)(root.val-target))? preVal.get(0) : root.val);
            return;
        }
        else {
            preVal.set(0, root.val);
        }
        helper(root.right, target, preVal, res);
    }
}

 Recursion: （转）根据二叉树的性质，我们知道当遍历到某个根节点时，最近的那个节点要么是在子树里面，要么就是根节点本身。所以我们根据这个递归，返回子树中最近的节点，和根节点中更近的那个就行了。

public class Solution {
    public int closestValue(TreeNode root, double target) {
        // 选出子树的根节点
        TreeNode kid = target < root.val ? root.left : root.right;
        // 如果没有子树，也就是递归到底时，直接返回当前节点值
        if(kid == null) return root.val;
        // 找出子树中最近的那个节点
        int closest = closestValue(kid, target);
        // 返回根节点和子树最近节点中，更近的那个节点
        return Math.abs(root.val - target) < Math.abs(closest - target) ? root.val : closest;
    }
}

Iteration: (转)

public class Solution {
    public int closestValue(TreeNode root, double target) {
        int closest = root.val;
        while(root != null){
            // 如果该节点的离目标更近，则更新到目前为止的最近值
            closest = Math.abs(closest - target) < Math.abs(root.val - target) ? closest : root.val;
            // 二叉搜索
            root = target < root.val ? root.left : root.right;
        }
        return closest;
    }
}