enable TypeName check

Author: fishercoder1534

README.md

@@ -434,7 +434,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |186|[Reverse Words in a String II](https://leetcode.com/problems/reverse-words-in-a-string-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_186.java)| O(n)|O(1)| Medium
 |179|[Largest Number](https://leetcode.com/problems/largest-number/)|[Solution](../../master/src/main/java/com/fishercoder/solutions/_179.java)| O(?) |O(?) | Medium|
 |174|[Dungeon Game](https://leetcode.com/problems/dungeon-game/)|[Queue](../master/src/main/java/com/fishercoder/solutions/BSTIterator_using_q.java) [Stack](../../blmaster/MEDIUM/src/medium/_174.java)| O(m*n) |O(m*n) | Hard| DP
-|173|[Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/)|[Queue](../master/src/main/java/com/fishercoder/solutions/_173_using_q.java) [Stack](../../blmaster/MEDIUM/src/medium/_173_using_stack.java)| O(1) |O(h) | Medium| Stack, Design
+|173|[Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/)|[Solution](../../blmaster/MEDIUM/src/medium/_173.java)| O(1) |O(h) | Medium| Stack, Design
 |172|[Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_172.java)| O(logn)|O(1)| Easy
 |171|[Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_171.java)| O(n)|O(1)| Easy
 |170|[Two Sum III - Data structure design](https://leetcode.com/problems/two-sum-iii-data-structure-design/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_170.java)| O(n)|O(n)| Easy

fishercoder_checkstyle.xml

@@ -108,10 +108,11 @@
             <message key="name.invalidPattern"
                      value="Package name ''{0}'' must match pattern ''{1}''."/>
         </module>
-        <!--<module name="TypeName">-->
-            <!--<message key="name.invalidPattern"-->
-                     <!--value="Type name ''{0}'' must match pattern ''{1}''."/>-->
-        <!--</module>-->
+        <module name="TypeName">
+            <property name="format" value="^[_]*[0-9]*[a-zA-Z0-9]*$"/>
+            <message key="name.invalidPattern"
+                     value="Type name ''{0}'' must match pattern ''{1}''."/>
+        </module>
         <module name="MemberName">
             <property name="format" value="^[a-z]*[a-z0-9][a-zA-Z0-9]*$"/>
             <message key="name.invalidPattern"

src/main/java/com/fishercoder/solutions/_110.java

@@ -9,7 +9,7 @@
 
 public class _110 {
 
-    class Solution_1 {
+    class Solution1 {
         //recursively get the height of each subtree of each node, compare their difference, if greater than 1, then return false
         //although this is working, but it's not efficient, since it repeatedly computes the heights of each node every time
         //Its time complexity is O(n^2).
@@ -27,7 +27,7 @@ private int getH(TreeNode root) {
         }
     }
 
-    class Solution_2 {
+    class Solution2 {
 
         public boolean isBalanced(TreeNode root) {
             return getH(root) != -1;

src/main/java/com/fishercoder/solutions/_119.java

@@ -35,7 +35,7 @@ public List<Integer> getRow(int rowIndex) {
         }
     }
 
-    public static class Solution_OkSpace {
+    public static class SolutionOkSpace {
         public List<Integer> getRow(int rowIndex) {
             List<Integer> row = new ArrayList<>();
             for (int i = 0; i < rowIndex + 1; i++) {

src/main/java/com/fishercoder/solutions/_128.java

@@ -65,7 +65,7 @@ public int maxUnion(){//this is O(n)
         }
     }
 
-    class Solution_using_HashSet{
+    class SolutionUsingHashSet {
     //inspired by this solution: https://discuss.leetcode.com/topic/25493/simple-fast-java-solution-using-set
         public int longestConsecutive(int[] nums) {
             if(nums == null || nums.length == 0) return 0;

src/main/java/com/fishercoder/solutions/_129.java

@@ -48,7 +48,7 @@ private void dfs(TreeNode root, StringBuilder sb, List<Integer> allNumbers) {
         sb.deleteCharAt(sb.length()-1);
     }
 
-    class more_concise_version {
+    class MoreConciseVersion {
         public int sumNumbers(TreeNode root) {
             return dfs(root, 0);
         }

src/main/java/com/fishercoder/solutions/_173.java

@@ -0,0 +1,92 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.LinkedList;
+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.
+ * <p>
+ * Calling next() will return the next smallest number in the BST.
+ * <p>
+ * 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 BSTIterator {
+
+            private Queue<Integer> queue;
+
+            /**
+             * My natural idea is to use a queue to hold all elements in the BST, traverse it while constructing the iterator, although
+             * this guarantees O(1) hasNext() and next() time, but it uses O(n) memory.
+             */
+            //Cheers! Made it AC'ed at first shot! Praise the Lord! Practice does make perfect!
+            //I created a new class to do it using Stack to meet O(h) memory: {@link fishercoder.algorithms._173_using_stack}
+            public BSTIterator(TreeNode root) {
+                queue = new LinkedList<Integer>();
+                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);
+            }
+
+            /**
+             * @return whether we have a next smallest number
+             */
+            public boolean hasNext() {
+                return !queue.isEmpty();
+            }
+
+            /**
+             * @return the next smallest number
+             */
+            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!
+             */
+
+            private Stack<TreeNode> 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;
+                }
+            }
+
+            public boolean hasNext() {
+                return !stack.isEmpty();
+            }
+
+            public int next() {
+                TreeNode curr = stack.pop();
+                pushToStack(curr.right, stack);
+                return curr.val;
+            }
+        }
+    }
+}

src/main/java/com/fishercoder/solutions/_173_using_queue.java

@@ -9,7 +9,7 @@
  You are guaranteed to have only one unique value in the BST that is closest to the target.*/
 public class _270 {
 
-    class General_tree_solution {
+    class GeneralTreeSolution {
         //this finished in 1 ms
         public int closestValue(TreeNode root, double target) {
             if (root == null)
@@ -33,7 +33,7 @@ private int dfs(TreeNode root, double target, double delta, int closestVal) {
         }
     }
 
-    class BST_solution_recursive{
+    class BSTSolutionRecursive {
         //we can tailor the solution to use the BST feature: left subtrees are always smaller than the root the right subtrees
         //this finished in 0 ms
         public int closestValue(TreeNode root, double target) {
@@ -55,7 +55,7 @@ private int dfs(TreeNode root, double target, int minVal) {
         }
     }
 
-    class General_tree_solution_more_concise{
+    class GeneralTreeSolutionMoreConcise {
         public int closestValue(TreeNode root, double target) {
             if(root == null) return 0;
             return dfs(root, target, root.val);
@@ -73,7 +73,7 @@ private int dfs(TreeNode root, double target, int minVal) {
         }
     }
 
-    class BST_solution_iterative{
+    class BSTSolutionIterative {
         public int closestValue(TreeNode root, double target) {
             long minVal = Long.MAX_VALUE;
             while(root != null){