refactor format

Author: fishercoder1534

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

@@ -27,17 +27,17 @@ Given a binary tree, check whether it is a mirror of itself (ie, symmetric aroun
 public class _101 {
 	//a very natural idea flows out using recursion. Cheers.
 	public boolean isSymmetric(TreeNode root) {
-		if(root == null) {
+		if (root == null) {
 			return true;
 		}
 		return isSymmetric(root.left, root.right);
 	}
 
 	private boolean isSymmetric(TreeNode left, TreeNode right) {
-		if(left == null || right == null) {
+		if (left == null || right == null) {
 			return left == right;
 		}
-		if(left.val != right.val) {
+		if (left.val != right.val) {
 			return false;
 		}
 		return isSymmetric(left.left, right.right) && isSymmetric(left.right, right.left);

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

@@ -11,18 +11,20 @@
  You may assume that duplicates do not exist in the tree.*/
 public class _105 {
 
-	/**credit: https://discuss.leetcode.com/topic/29838/5ms-java-clean-solution-with-caching
-	use HashMap as the cache so that accessing inorder index becomes O(1) time
-
-	 Note: The first element of preorder array is the root!*/
+	/**
+	 * credit: https://discuss.leetcode.com/topic/29838/5ms-java-clean-solution-with-caching
+	 * use HashMap as the cache so that accessing inorder index becomes O(1) time
+	 * <p>
+	 * Note: The first element of preorder array is the root!
+	 */
 	public TreeNode buildTree(int[] preorder, int[] inorder) {
 		Map<Integer, Integer> inorderMap = new HashMap();
 		for (int i = 0; i < inorder.length; i++) {
 			inorderMap.put(inorder[i], i);
 		}
 
 		/**At the beginning, both start from 0 to nums.length-1*/
-		return buildTree(preorder, 0, preorder.length-1, 0, inorder.length-1, inorderMap);
+		return buildTree(preorder, 0, preorder.length - 1, 0, inorder.length - 1, inorderMap);
 	}
 
 	private TreeNode buildTree(int[] preorder, int preStart, int preEnd, int inStart, int inEnd, Map<Integer, Integer> inorderMap) {
@@ -39,8 +41,8 @@ private TreeNode buildTree(int[] preorder, int preStart, int preEnd, int inStart
 		 *
 		 * since inRoot is being used already in this recursion call, that's why we use inRoot-1 and inRoot+1
 		 * this part is the same for both Leetcode 105 and Leetcode 106.*/
-		root.left = buildTree(preorder, preStart+1, preStart+numsLeft, inStart, inRoot-1, inorderMap);
-		root.right = buildTree(preorder, preStart+numsLeft+1, preEnd, inRoot+1, inEnd, inorderMap);
+		root.left = buildTree(preorder, preStart + 1, preStart + numsLeft, inStart, inRoot - 1, inorderMap);
+		root.right = buildTree(preorder, preStart + numsLeft + 1, preEnd, inRoot + 1, inEnd, inorderMap);
 		return root;
 	}
 

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

@@ -16,13 +16,15 @@
  */
 public class _106 {
 
-    /**https://discuss.leetcode.com/topic/3296/my-recursive-java-code-with-o-n-time-and-o-n-space
-     *
+    /**
+     * https://discuss.leetcode.com/topic/3296/my-recursive-java-code-with-o-n-time-and-o-n-space
+     * <p>
      * Note: the last element of postorder array is the root!
-     *
+     * <p>
      * The idea is to take the last element in postorder as the root; find the position of the root in the inorder array;
      * then locate the range for left sub-tree and right sub-tree and do recursion,
-     * use a hashmap to record the index of root in the inorder array.*/
+     * use a hashmap to record the index of root in the inorder array.
+     */
     public TreeNode buildTree(int[] inorder, int[] postorder) {
         if (inorder == null || postorder == null || inorder.length != postorder.length) {
             return null;
@@ -32,14 +34,14 @@ public TreeNode buildTree(int[] inorder, int[] postorder) {
             inorderMap.put(inorder[i], i);
         }
         /**At the beginning, both start from 0 to nums.length-1*/
-        return buildTreeRecursively(0, inorder.length-1, postorder, 0, postorder.length-1,inorderMap);
+        return buildTreeRecursively(0, inorder.length - 1, postorder, 0, postorder.length - 1, inorderMap);
     }
 
-    private TreeNode buildTreeRecursively(int inorderStart, int inorderEnd, int[] postorder, int postorderStart, int postorderEnd, Map<Integer, Integer> inorderMap){
+    private TreeNode buildTreeRecursively(int inorderStart, int inorderEnd, int[] postorder, int postorderStart, int postorderEnd, Map<Integer, Integer> inorderMap) {
         if (postorderStart > postorderEnd || inorderStart > inorderEnd) return null;
         TreeNode root = new TreeNode(postorder[postorderEnd]);
         int inRoot = inorderMap.get(postorder[postorderEnd]);
-        int numsLeft = inRoot-inorderStart;
+        int numsLeft = inRoot - inorderStart;
 
         /**It's easy to understand and remember:
          * for the indices of inorder array:
@@ -55,10 +57,9 @@ private TreeNode buildTreeRecursively(int inorderStart, int inorderEnd, int[] po
          * this is also easy to understand and remember:
          * since the last one in postorder is the root and we have used it in this recursion call already, so the end is definitely postorderEnd-1;
          * then the postorderEnd for root.left is contiguous to the postorderStart of root.right, :)*/
-        root.left = buildTreeRecursively(inorderStart, inRoot-1, postorder, postorderStart, postorderStart+numsLeft-1, inorderMap);
-        root.right = buildTreeRecursively(inRoot+1, inorderEnd, postorder, postorderStart+numsLeft, postorderEnd-1, inorderMap);
+        root.left = buildTreeRecursively(inorderStart, inRoot - 1, postorder, postorderStart, postorderStart + numsLeft - 1, inorderMap);
+        root.right = buildTreeRecursively(inRoot + 1, inorderEnd, postorder, postorderStart + numsLeft, postorderEnd - 1, inorderMap);
         return root;
     }
 
-
 }

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

@@ -34,18 +34,18 @@
 public class _107 {
 	public List<List<Integer>> levelOrder(TreeNode root) {
 		List<List<Integer>> result = new ArrayList();
-		if(root == null) return result;
-		
+		if (root == null) return result;
+
 		Queue<TreeNode> q = new LinkedList();
 		q.offer(root);
-		while(!q.isEmpty()){
+		while (!q.isEmpty()) {
 			List<Integer> thisLevel = new ArrayList<Integer>();
 			int qSize = q.size();
-			for(int i = 0; i < qSize; i++){
+			for (int i = 0; i < qSize; i++) {
 				TreeNode curr = q.poll();
 				thisLevel.add(curr.val);
-				if(curr.left != null) q.offer(curr.left);
-				if(curr.right != null) q.offer(curr.right);
+				if (curr.left != null) q.offer(curr.left);
+				if (curr.right != null) q.offer(curr.right);
 			}
 			result.add(thisLevel);
 		}

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

@@ -8,25 +8,25 @@
  For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.*/
 
 public class _110 {
-    
+
     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).
         public boolean isBalanced(TreeNode root) {
-            if(root == null) return true;
-            if(Math.abs(getH(root.left) - getH(root.right)) > 1) return false;
+            if (root == null) return true;
+            if (Math.abs(getH(root.left) - getH(root.right)) > 1) return false;
             else return isBalanced(root.left) && isBalanced(root.right);
         }
 
         private int getH(TreeNode root) {
-            if(root == null) return 0;//base case
+            if (root == null) return 0;//base case
             int leftH = getH(root.left);
             int rightH = getH(root.right);
-            return Math.max(leftH, rightH)+1;
+            return Math.max(leftH, rightH) + 1;
         }
     }
-    
+
     class Solution2 {
 
         public boolean isBalanced(TreeNode root) {

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

@@ -17,8 +17,8 @@
 return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.*/
 public class _112 {
     public boolean hasPathSum(TreeNode root, int sum) {
-        if(root == null) return false;
-        if(root.val == sum && root.left == null && root.right == null) return true;
+        if (root == null) return false;
+        if (root.val == sum && root.left == null && root.right == null) return true;
         return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
     }
 

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

@@ -28,37 +28,37 @@ public class _113 {
     //also, it's possible that a node's value could be negative, as long as the sum of root to leaf ends up to sum
     public List<List<Integer>> pathSum(TreeNode root, int sum) {
         List<List<Integer>> allPaths = new ArrayList();
-        if(root == null) return allPaths;
+        if (root == null) return allPaths;
         List<Integer> path = new ArrayList();
         dfs(root, path, allPaths, sum);
         return allPaths;
     }
 
-    
+
     private void dfs(TreeNode root, List<Integer> path, List<List<Integer>> allPaths, int sum) {
         path.add(root.val);
-        if(root.left != null){
-            dfs(root.left, path, allPaths, sum-root.val);
+        if (root.left != null) {
+            dfs(root.left, path, allPaths, sum - root.val);
         }
-        if(root.right != null){
-            dfs(root.right, path, allPaths, sum-root.val);
+        if (root.right != null) {
+            dfs(root.right, path, allPaths, sum - root.val);
         }
-        if(root.left == null && root.right == null){
-            if(sum == root.val){
+        if (root.left == null && root.right == null) {
+            if (sum == root.val) {
                 List<Integer> onePath = new ArrayList(path);
                 allPaths.add(onePath);
             }
         }
-        path.remove(path.size()-1);
+        path.remove(path.size() - 1);
     }
 
 
-    public static void main(String...strings){
+    public static void main(String... strings) {
         _113 test = new _113();
 //        TreeNode root = new TreeNode(1);
 //        root.left = new TreeNode(2);
 //        int sum = 1;
-        
+
 //        TreeNode root = new TreeNode(1);
 //        root.left = new TreeNode(-2);
 //        root.left.left = new TreeNode(1);
@@ -74,7 +74,7 @@ public static void main(String...strings){
 //     1   3 -2 
 //    /      
 //   -1
-        
+
         TreeNode root = new TreeNode(5);
         root.left = new TreeNode(4);
         root.left.left = new TreeNode(11);

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

@@ -12,29 +12,29 @@ public class _115 {
 
     public int numDistinct(String s, String t) {
         int m = s.length(), n = t.length();
-        int[][] dp = new int[m+1][n+1];
-        
+        int[][] dp = new int[m + 1][n + 1];
+
         char[] schar = s.toCharArray();
         char[] tchar = t.toCharArray();
-        
-        for(int i = 0; i <= m; i++) {
+
+        for (int i = 0; i <= m; i++) {
             dp[i][0] = 1;
         }
-        
-        for(int j = 1; j <= n; j++) {
+
+        for (int j = 1; j <= n; j++) {
             dp[0][j] = 0;
         }
-        
-        for(int i = 1; i <= m; i++){
-            for(int j = 1; j <= n; j++){
-                if(schar[i-1] == tchar[j-1]) {
-                    dp[i][j] = dp[i-1][j]+dp[i-1][j-1];
+
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                if (schar[i - 1] == tchar[j - 1]) {
+                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
                 } else {
-                    dp[i][j] = dp[i-1][j];
+                    dp[i][j] = dp[i - 1][j];
                 }
             }
         }
-        
+
         return dp[m][n];
     }
 

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

@@ -71,7 +71,7 @@ public static void connect(TreeLinkNode root) {
 
     }
 
-    public static void main(String...args){
+    public static void main(String... args) {
         TreeLinkNode root = new TreeLinkNode(1);
         root.left = new TreeLinkNode(2);
         root.right = new TreeLinkNode(3);

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

@@ -68,7 +68,7 @@ public static void connect(TreeLinkNode root) {
 
     }
 
-    public static void main(String...args){
+    public static void main(String... args) {
         TreeLinkNode root = new TreeLinkNode(1);
         root.left = new TreeLinkNode(2);
         root.right = new TreeLinkNode(3);