Improved tasks 101-146.

Author: javadev

src.save/main/java/g0101_0200/s0101_symmetric_tree/Solution.java

@@ -10,19 +10,16 @@ public boolean isSymmetric(TreeNode root) {
         if (root == null) {
             return true;
         }
-
         return helper(root.left, root.right);
     }
 
     private boolean helper(TreeNode leftNode, TreeNode rightNode) {
         if (leftNode == null || rightNode == null) {
             return leftNode == null && rightNode == null;
         }
-
         if (leftNode.val != rightNode.val) {
             return false;
         }
-
         return helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left);
     }
 }

src.save/main/java/g0101_0200/s0102_binary_tree_level_order_traversal/Solution.java

@@ -23,14 +23,12 @@ public List<List<Integer>> levelOrder(TreeNode root) {
             root = queue.remove();
             while (!queue.isEmpty() && root != null) {
                 level.add(root.val);
-
                 if (root.left != null) {
                     queue.add(root.left);
                 }
                 if (root.right != null) {
                     queue.add(root.right);
                 }
-
                 root = queue.remove();
             }
             result.add(level);

src.save/main/java/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.java

@@ -8,8 +8,8 @@
 import java.util.Map;
 
 public class Solution {
-    int j;
-    Map<Integer, Integer> map = new HashMap<>();
+    private int j;
+    private Map<Integer, Integer> map = new HashMap<>();
 
     public int get(int key) {
         return map.get(key);

src.save/main/java/g0101_0200/s0107_binary_tree_level_order_traversal_ii/Solution.java

@@ -8,7 +8,7 @@
 import java.util.List;
 
 public class Solution {
-    List<List<Integer>> order = new ArrayList<>();
+    private List<List<Integer>> order = new ArrayList<>();
 
     public List<List<Integer>> levelOrderBottom(TreeNode root) {
         getOrder(root, 0);

src.save/main/java/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/Solution.java

@@ -10,20 +10,17 @@ public TreeNode sortedArrayToBST(int[] num) {
         return makeTree(num, 0, num.length - 1);
     }
 
-    public TreeNode makeTree(int[] num, int left, int right) {
+    private TreeNode makeTree(int[] num, int left, int right) {
         /*2. left as lowest# can't be greater than right*/
         if (left > right) {
             return null;
         }
-
         /*3. Set median# as node*/
         int mid = (left + right) / 2;
         TreeNode midNode = new TreeNode(num[mid]);
-
         /*4. Set mid node's kids*/
         midNode.left = makeTree(num, left, mid - 1);
         midNode.right = makeTree(num, mid + 1, right);
-
         /*5. Sends node back || Goes back to prev node*/
         return midNode;
     }

src.save/main/java/g0101_0200/s0109_convert_sorted_list_to_binary_search_tree/Solution.java

@@ -11,35 +11,28 @@ public TreeNode sortedListToBST(ListNode head) {
         if (head == null) {
             return null;
         }
-
         // No next node -> this node will become leaf
         if (head.next == null) {
             TreeNode leaf = new TreeNode(head.val);
             leaf.left = null;
             leaf.right = null;
             return leaf;
         }
-
         ListNode slow = head;
         // Head-Start fast by 1 to get slow = mid -1
         ListNode fast = head.next.next;
-
         // Find the mid of list
         while (fast != null && fast.next != null) {
             slow = slow.next;
             fast = fast.next.next;
         }
-
         // slow.next ->  mid = our "root"
         TreeNode root = new TreeNode(slow.next.val);
-
         // Right sub tree from mid - end
         root.right = sortedListToBST(slow.next.next);
-
         // Left sub tree from head - mid (chop slow.next)
         slow.next = null;
         root.left = sortedListToBST(head);
-
         return root;
     }
 }

src.save/main/java/g0101_0200/s0110_balanced_binary_tree/Solution.java

@@ -6,53 +6,42 @@
 
 public class Solution {
     public boolean isBalanced(TreeNode root) {
-
         // Empty Tree is balanced
         if (root == null) {
             return true;
         }
-
         // Get max height of subtree child
         // Get max height of subtree child
         // compare height difference (cannot be more than 1)
         int leftHeight = 0;
         int rightHeight = 0;
-
         if (root.left != null) {
             leftHeight = getMaxHeight(root.left);
         }
-
         if (root.right != null) {
             rightHeight = getMaxHeight(root.right);
         }
-
         int heightDiff = Math.abs(leftHeight - rightHeight);
-
         // if passes height check
         //  - Check if left subtree is balanced and if the right subtree is balanced
         //  - If one of both are imbalanced, then the tree is imbalanced
         return heightDiff <= 1 && isBalanced(root.left) && isBalanced(root.right);
     }
 
-    public int getMaxHeight(TreeNode root) {
-
+    private int getMaxHeight(TreeNode root) {
         if (root == null) {
             return 0;
         }
-
         int leftHeight = 0;
         int rightHeight = 0;
-
         // Left
         if (root.left != null) {
             leftHeight = getMaxHeight(root.left);
         }
-
         // Right
         if (root.right != null) {
             rightHeight = getMaxHeight(root.right);
         }
-
         if (leftHeight > rightHeight) {
             return 1 + leftHeight;
         } else {

src.save/main/java/g0101_0200/s0115_distinct_subsequences/Solution.java

@@ -16,7 +16,6 @@ public int numDistinct(String text, String text2) {
         int[] dp = new int[move];
         int j = 1;
         int k = 1;
-
         for (int i = 0; i < text2.length(); i++) {
             boolean firstMatch = true;
             for (; j < move; j++) {
@@ -40,7 +39,6 @@ public int numDistinct(String text, String text2) {
             if (dp[move - 1] == 0) {
                 return 0;
             }
-
             j = k;
         }
         return dp[move - 1];

src.save/main/java/g0101_0200/s0117_populating_next_right_pointers_in_each_node_ii/Solution.java

@@ -43,11 +43,9 @@ public Node connect(Node root) {
                 root.left.next = adjacentRightNode(root.next);
             }
         }
-
         if (root.right != null) {
             root.right.next = adjacentRightNode(root.next);
         }
-
         connect(root.right);
         connect(root.left);
         return root;

src.save/main/java/g0101_0200/s0118_pascals_triangle/Solution.java

@@ -9,7 +9,6 @@
 public class Solution {
     public List<List<Integer>> generate(int numRows) {
         List<List<Integer>> output = new ArrayList<>();
-
         for (int i = 0; i < numRows; i++) {
             List<Integer> currRow = new ArrayList<>();
             for (int j = 0; j <= i; j++) {