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){

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

@@ -24,7 +24,7 @@
 
  */
 public class _286 {
-    class BFS_solution_without_queue{
+    class BFSSolutionWithoutQueue {
 
         int[] dirs = new int[]{0,1,0,-1,0};
         public void wallsAndGates(int[][] rooms) {
@@ -50,7 +50,7 @@ void bfs(int[][] rooms, int i, int j, int m, int n){
 
     }
 
-    class BFS_solution_with_a_queue{
+    class BFSSolutionWithAQueue {
 
         //push all gates into the queue first, and then put all its neighbours into the queue with one distance to the gate, then continue to push the rest of the nodes into the queue, and put all their neighbours into the queue with the nodes' value plus one until the queue is empty
         int[] dirs = new int[]{0,1,0,-1,0};

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

@@ -29,7 +29,7 @@ public int findDuplicate(int[] nums) {
         return dup;
     }
 
-    class Solution_O1 {
+    class SolutionO1 {
         public int findDuplicate(int[] nums) {
             int slow = 0;
             int fast = 0;

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

@@ -60,11 +60,11 @@ public double findMedian() {
 
     }
 
-    public static class MedianFinder_verbose {
+    public static class MedianFinderVerbose {
         private Queue<Long> large;
         private Queue<Long> small;
 
-        public MedianFinder_verbose() {
+        public MedianFinderVerbose() {
             large = new PriorityQueue<>();
             small = new PriorityQueue<>(Collections.reverseOrder());
         }

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

@@ -24,7 +24,7 @@ Space complexity should be O(n).
 *
 */
 public class _338 {
-    private class DP_Solution{
+    private class DPSolution {
         //lixx2100's post is cool:https://discuss.leetcode.com/topic/40162/three-line-java-solution
         //An easy recurrence for this problem is f[i] = f[i / 2] + i % 2
         //and then we'll use bit manipulation to express the above recursion function

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

@@ -5,7 +5,7 @@
 import java.util.List;
 
 public class _339 {
-    class Solution_with_global_sum {
+    class SolutionWithGlobalSum {
         private int sum = 0;
 
         public int depthSum(List<NestedInteger> nestedList) {
@@ -24,7 +24,7 @@ private int dfs(List<NestedInteger> nestedList, int depth) {
         }
     }
 
-    class Solution_with_local_sum {
+    class SolutionWithLocalSum {
         public int depthSum(List<NestedInteger> nestedList) {
             return dfs(nestedList, 1);
         }

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

@@ -26,17 +26,17 @@ public class _384 {
 
     public static void main(String... strings) {
         int[] nums = new int[]{1, 2, 3};
-        Solution_for_this_question test = new Solution_for_this_question(nums);
+        Solution test = new Solution(nums);
     }
 
-    public static class Solution_for_this_question {
+    public static class Solution {
         //Note: the problem states that this is a set without duplicates which makes building all combinations easier
 
         private List<List<Integer>> combinations;
         private int[] original;
         private Random random;
 
-        public Solution_for_this_question(int[] nums) {
+        public Solution(int[] nums) {
             original = nums;
             random = new Random();
             combinations = buildAllComb(nums);

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

@@ -47,12 +47,12 @@ public int pick(int target) {
     }
 
 
-    class Solution_MemoryLimitExceeded {
+    class SolutionMemoryLimitExceeded {
 
         private Map<Integer, List<Integer>> map = new HashMap();
         java.util.Random rand = new java.util.Random();
 
-        public Solution_MemoryLimitExceeded(int[] nums) {
+        public SolutionMemoryLimitExceeded(int[] nums) {
             for (int i = 0; i < nums.length; i++) {
                 if (map.containsKey(nums[i])) {
                     List<Integer> list = map.get(nums[i]);

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

@@ -37,7 +37,7 @@ private int dfs(TreeNode root, int result, boolean left) {
         return leftResult + rightResult;
     }
 
-    private class Solution_more_concise{
+    private class Solution2 {
 
         public int sumOfLeftLeaves(TreeNode root) {
             int sum = 0;