fd

Author: dingjikerbo

app/build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'com.android.application'
 
 android {
     compileSdkVersion 24
-    buildToolsVersion '25.0.0'
+    buildToolsVersion '26.0.2'
     defaultConfig {
         applicationId "com.inuker.leetcode"
         minSdkVersion 18

build.gradle

@@ -5,7 +5,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.3.0'
+        classpath 'com.android.tools.build:gradle:3.0.0'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

solution/src/main/java/com/inuker/solution/InorderSuccessorInBST.java

@@ -56,4 +56,29 @@ public TreeNode inorderSuccessor2(TreeNode root, TreeNode p) {
         }
         return res;
     }
+
+    /**
+     * http://www.geeksforgeeks.org/?p=9999
+     * 给定Node，求其successor，步骤如下：
+     * 1， 如果Node.right != null，则在Node.right中找最小的那个节点，即从Node.right开始，最左下角的节点
+     * 2， 如果Node.right == null，则不断往parent走，直到当前节点是其parent的左节点为止，其parent即为给定Node的successor
+    private TreeNode inOrderSuccessor(TreeNode root, TreeNode node) {
+        if (node.right != null) {
+            return minValue(node.right);
+        }
+
+        TreeNode parent = node.parent;
+        while (parent != null && node == parent.right) {
+            node = parent;
+            parent = parent.parent;
+        }
+        return parent;
+    }
+
+     private TreeNode minValue(TreeNode node) {
+        while (node.left != null) {
+            node = node.left;
+        }
+        return node;
+    }*/
 }

test/src/main/java/com/inuker/test/main.java

@@ -3,7 +3,9 @@
 import com.inuker.solution.BinaryTreeInorderTraversal;
 import com.leetcode.library.TreeNode;
 
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Stack;
 
 public class main {
 
@@ -20,16 +22,42 @@ public static void main(String[] args) {
         }
     }
 
-    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
-        TreeNode node = null;
-        while (root != null) {
-            if (p.val < root.val) {
-                node = root;
-                root = root.left;
+    public List<Integer> closestKValues(TreeNode root, double target, int k) {
+        Stack<Integer> smaller = new Stack<>();
+        Stack<Integer> larger = new Stack<>();
+        helper(root, smaller, target, true);
+        helper(root, larger, target, false);
+        List<Integer> result = new LinkedList<>();
+        for (int i = 0; i < k; i++) {
+            if (smaller.isEmpty()) {
+                result.add(larger.pop());
+            } else if (larger.isEmpty()) {
+                result.add(smaller.pop());
+            } else if (Math.abs(smaller.peek() - target) < Math.abs(larger.peek() - target)) {
+                result.add(smaller.pop());
             } else {
-                root = root.right;
+                result.add(larger.pop());
+            }
+        }
+        return result;
+    }
+
+    private void helper(TreeNode root, Stack<Integer> stack0, double target, boolean smaller) {
+        Stack<TreeNode> stack = new Stack<>();
+        while (!stack.isEmpty() || root != null) {
+            if (root != null) {
+                stack.push(root);
+                root = smaller ? root.left : root.right;
+            } else {
+                root = stack.pop();
+
+                if ((smaller && root.val >= target) || (!smaller && root.val < target)) {
+                    return;
+                }
+
+                stack0.push(root.val);
+                root = smaller ? root.right : root.left;
             }
         }
-        return node;
     }
 }