refactor 173

fishercoder1534 · fishercoder1534 · commit 8d816af6ae01 · 2020-12-09T07:58:53.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_173.java b/src/main/java/com/fishercoder/solutions/_173.java
@@ -6,81 +6,72 @@
 import java.util.Queue;
 import java.util.Stack;
 
-/**
- * 173. Binary Search Tree Iterator
- *
- * Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.
- *
- * Calling next() will return the next smallest number in the BST.
- *
- * Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.
- */
 public class _173 {
 
-  public static class Solution1 {
+    public static class Solution1 {
 
-    public static class BSTIterator {
-      private Queue<Integer> queue;
+        public static class BSTIterator {
+            private Queue<Integer> queue;
 
-      public BSTIterator(TreeNode root) {
-        queue = new LinkedList<>();
-        if (root != null) {
-          dfs(root, queue);
-        }
-      }
+            public BSTIterator(TreeNode root) {
+                queue = new LinkedList<>();
+                if (root != null) {
+                    dfs(root, queue);
+                }
+            }
 
-      private void dfs(TreeNode root, Queue<Integer> q) {
-        if (root.left != null) {
-          dfs(root.left, q);
-        }
-        q.offer(root.val);
-        if (root.right != null) {
-          dfs(root.right, q);
-        }
-      }
+            private void dfs(TreeNode root, Queue<Integer> q) {
+                if (root.left != null) {
+                    dfs(root.left, q);
+                }
+                q.offer(root.val);
+                if (root.right != null) {
+                    dfs(root.right, q);
+                }
+            }
 
-      public boolean hasNext() {
-        return !queue.isEmpty();
-      }
+            public boolean hasNext() {
+                return !queue.isEmpty();
+            }
 
-      public int next() {
-        return queue.poll();
-      }
+            public int next() {
+                return queue.poll();
+            }
+        }
     }
-  }
 
-  public static class Solution2 {
-    public static class BSTIterator {
-      /**
-       * This is a super cool/clever idea: use a stack to store all the current left nodes of the BST, when pop(), we
-       * push all its right nodes into the stack if there are any.
-       * This way, we use only O(h) memory for this iterator, this is a huge saving when the tree is huge
-       * since h could be much smaller than n. Cheers!
-       */
+    public static class Solution2 {
+        public static class BSTIterator {
+            /**
+             * This is a super cool/clever idea: use a stack to store all the current left nodes of the BST, when pop(), we
+             * push all its right nodes into the stack if there are any.
+             * This way, we use only O(h) memory for this iterator, this is a huge saving when the tree is huge
+             * since h could be much smaller than n. Cheers!
+             */
 
-      private Stack<TreeNode> stack;
+            private Stack<TreeNode> stack;
 
-      public BSTIterator(TreeNode root) {
-        stack = new Stack();
-        pushToStack(root, stack);
-      }
+            public BSTIterator(TreeNode root) {
+                stack = new Stack();
+                pushToStack(root, stack);
+            }
 
-      private void pushToStack(TreeNode root, Stack<TreeNode> stack) {
-        while (root != null) {
-          stack.push(root);
-          root = root.left;
-        }
-      }
+            private void pushToStack(TreeNode root, Stack<TreeNode> stack) {
+                while (root != null) {
+                    stack.push(root);
+                    root = root.left;
+                }
+            }
 
-      public boolean hasNext() {
-        return !stack.isEmpty();
-      }
+            public boolean hasNext() {
+                return !stack.isEmpty();
+            }
 
-      public int next() {
-        TreeNode curr = stack.pop();
-        pushToStack(curr.right, stack);
-        return curr.val;
-      }
+            public int next() {
+                TreeNode curr = stack.pop();
+                pushToStack(curr.right, stack);
+                return curr.val;
+            }
+        }
     }
-  }
 }
