LC刷题4/5 - Top FB Questions - M270/ M973

原创于 2020-04-06 15:05:10 发布 · 223 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

本文介绍三种高效算法，用于在二叉搜索树中查找最接近目标值的节点值。包括递归中序遍历加线性搜索、迭代中序遍历及二分查找方法，分别分析其时间复杂度和空间复杂度。

4/5 Facebook Medium Questions

270. Closest Binary Search Tree Value

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int closestValue(TreeNode root, double target) {
        return (int) iterValue(root, target);
    }
    
    
    public double iterValue(TreeNode root, double target) {
        double iterVal = -1; 
        if (root == null) 
            return Double.MAX_VALUE;
        if (target < root.val) {
            iterVal = iterValue(root.left, target);
        } else if (target > root.val) {
            iterVal = iterValue(root.right, target);
        } else {
            iterVal = target;
        }
        
        if (Math.abs(iterVal-target) > Math.abs(root.val-target)) {
            iterVal = root.val;
        }
        
        return iterVal;
    }
}

Solution

Approach 1: Recursive Inorder + Linear search, O(N) time

class Solution {
  public void inorder(TreeNode root, List<Integer> nums) {
    if (root == null) return;
    inorder(root.left, nums);
    nums.add(root.val);
    inorder(root.right, nums);
  }

  public int closestValue(TreeNode root, double target) {
    List<Integer> nums = new ArrayList();
    inorder(root, nums);
    return Collections.min(nums, new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
        return Math.abs(o1 - target) < Math.abs(o2 - target) ? -1 : 1;
      }
    });
  }
}

Complexity Analysis

Time complexity : O(N)\mathcal{O}(N)O(N) because to build inorder traversal and then to perform linear search takes linear time.
Space complexity : O(N)\mathcal{O}(N)O(N) to keep inorder traversal.

Approach 2: Iterative Inorder, O(k) time

class Solution {
  public int closestValue(TreeNode root, double target) {
    LinkedList<TreeNode> stack = new LinkedList();
    long pred = Long.MIN_VALUE;

    while (!stack.isEmpty() || root != null) {
      while (root != null) {
        stack.add(root);
        root = root.left;
      }
      root = stack.removeLast();

      if (pred <= target && target < root.val)
        return Math.abs(pred - target) < Math.abs(root.val - target) ? (int)pred : root.val;

      pred = root.val;
      root = root.right;
    }
    return (int)pred;
  }
}

Approach 3: Binary Search, O(H) time

class Solution {
  public int closestValue(TreeNode root, double target) {
    int val, closest = root.val;
    while (root != null) {
      val = root.val;
      closest = Math.abs(val - target) < Math.abs(closest - target) ? val : closest;
      root =  target < root.val ? root.left : root.right;
    }
    return closest;
  }
}

Complexity Analysis

Time complexity : O(H)\mathcal{O}(H)O(H) since here one goes from root down to a leaf.

Space complexity : O(1)\mathcal{O}(1)O(1).

973. K Closest Points to Origin

在这里插入代码片