zoukankan      html  css  js  c++  java
  • [?]*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)?

     

    Hint:

    1. Consider implement these two helper functions:
      1. getPredecessor(N), which returns the next smaller node to N.
      2. getSuccessor(N), which returns the next larger node to N.
    2. Try to assume that each node has a parent pointer, it makes the problem much easier.
    3. Without parent pointer we just need to keep track of the path from the root to the current node using a stack.
    4. You would need two stacks to track the path in finding predecessor and successor node separately. 

    思路:

    The idea is to compare the predecessors and successors of the closest node to the target, we can use two stacks to track the predecessors and successors, then like what we do in merge sort, we compare and pick the closest one to the target and put it to the result list.

    As we know, inorder traversal gives us sorted predecessors, whereas reverse-inorder traversal gives us sorted successors.

    We can use iterative inorder traversal rather than recursion, but to keep the code clean, here is the recursion version.

    public List<Integer> closestKValues(TreeNode root, double target, int k) {
      List<Integer> res = new ArrayList<>();
    
      Stack<Integer> s1 = new Stack<>(); // predecessors
      Stack<Integer> s2 = new Stack<>(); // successors
    
      inorder(root, target, false, s1);
      inorder(root, target, true, s2);
    
      while (k-- > 0) {
        if (s1.isEmpty())
          res.add(s2.pop());
        else if (s2.isEmpty())
          res.add(s1.pop());
        else if (Math.abs(s1.peek() - target) < Math.abs(s2.peek() - target))
          res.add(s1.pop());
        else
          res.add(s2.pop());
      }
    
      return res;
    }
    
    // inorder traversal
    void inorder(TreeNode root, double target, boolean reverse, Stack<Integer> stack) {
      if (root == null) return;
    
      inorder(reverse ? root.right : root.left, target, reverse, stack);
      // early terminate, no need to traverse the whole tree
      if ((reverse && root.val <= target) || (!reverse && root.val > target)) return;
      // track the value of current node
      stack.push(root.val);
      inorder(reverse ? root.left : root.right, target, reverse, stack);
    }

    reference:https://leetcode.com/discuss/55240/ac-clean-java-solution-using-two-stacks

    解法二:

    public class Solution {
        public List<Integer> closestKValues(TreeNode root, double target, int k) {
            List<Integer> ret = new LinkedList<>();
            Stack<TreeNode> succ = new Stack<>();
            Stack<TreeNode> pred = new Stack<>();
            initializePredecessorStack(root, target, pred);
            initializeSuccessorStack(root, target, succ);
            if(!succ.isEmpty() && !pred.isEmpty() && succ.peek().val == pred.peek().val) {
                getNextPredecessor(pred);
            }
            while(k-- > 0) {
                if(succ.isEmpty()) {
                    ret.add(getNextPredecessor(pred));
                } else if(pred.isEmpty()) {
                    ret.add(getNextSuccessor(succ));
                } else {
                    double succ_diff = Math.abs((double)succ.peek().val - target);
                    double pred_diff = Math.abs((double)pred.peek().val - target);
                    if(succ_diff < pred_diff) {
                        ret.add(getNextSuccessor(succ));
                    } else {
                        ret.add(getNextPredecessor(pred));
                    }
                }
            }
            return ret;
        }
    
        private void initializeSuccessorStack(TreeNode root, double target, Stack<TreeNode> succ) {
            while(root != null) {
                if(root.val == target) {
                    succ.push(root);
                    break;
                } else if(root.val > target) {
                    succ.push(root);
                    root = root.left;
                } else {
                    root = root.right;
                }
            }
        }
    
        private void initializePredecessorStack(TreeNode root, double target, Stack<TreeNode> pred) {
            while(root != null){
                if(root.val == target){
                    pred.push(root);
                    break;
                } else if(root.val < target){
                    pred.push(root);
                    root = root.right;
                } else{
                    root = root.left;
                }
            }
        }
    
        private int getNextSuccessor(Stack<TreeNode> succ) {
            TreeNode curr = succ.pop();
            int ret = curr.val;
            curr = curr.right;
            while(curr != null) {
                succ.push(curr);
                curr = curr.left;
            }
            return ret;
        }
    
        private int getNextPredecessor(Stack<TreeNode> pred) {
            TreeNode curr = pred.pop();
            int ret = curr.val;
            curr = curr.left;
            while(curr != null) {
                pred.push(curr);
                curr = curr.right;
            }
            return ret;
        }
    }

    reference:https://leetcode.com/discuss/55682/o-logn-java-solution-with-two-stacks-following-hint

  • 相关阅读:
    【转】70个经典的 Shell 脚本面试问题
    【转】最牛B的编码套路
    【转】Flex 布局语法教程
    【转】程序员7大软技能测验 你得几分?
    【转】为什么事务日志自动增长会降低你的性能
    【hive】——metastore的三种模式
    【hive】——Hive基本操作
    【hive】——Hive初始了解
    【hive】——Hive四种数据导入方式
    【hive】——Hive sql语法详解
  • 原文地址:https://www.cnblogs.com/hygeia/p/5104293.html
Copyright © 2011-2022 走看看