refactor 272

fishercoder1534 · fishercoder1534 · commit a23e7f1607a6 · 2018-11-16T08:05:10.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_272.java b/src/main/java/com/fishercoder/solutions/_272.java
@@ -7,6 +7,8 @@
 import java.util.Stack;
 
 /**
+ * 272. 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:
@@ -28,44 +30,45 @@ Assume that the BST is balanced, could you solve it in less than O(n) runtime (w
  */
 public class _272 {
 
-	public List<Integer> closestKValues(TreeNode root, double target, int k) {
-		List<Integer> res = new ArrayList();
+    public static class Solution1 {
+        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
+            Stack<Integer> s1 = new Stack(); // predecessors
+            Stack<Integer> s2 = new Stack(); // successors
 
-		inorder(root, target, false, s1);
-		inorder(root, target, true, s2);
+            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());
-			}
-		}
+            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;
-	}
+            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);
-	}
+        // 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);
+        }
+    }
 }
