🎨 Format files (🛠️ from Github Actions)

Author: Ahmad-A0

java/1-Two-Sum.java

@@ -1,18 +1,19 @@
 class Solution {
-    public int[] twoSum(int[] nums, int target) {
-        HashMap<Integer, Integer> prevMap = new HashMap<>();
-        
-        for (int i = 0; i < nums.length; i++) {
-            int num = nums[i];
-            int diff = target - num;
-            
-            if (prevMap.containsKey(nums[i])) {
-                return new int[]{prevMap.get(num), i};
-            }
-            
-            prevMap.put(target - num, i);
-        }
-        
-        return new int[]{};
+
+  public int[] twoSum(int[] nums, int target) {
+    HashMap<Integer, Integer> prevMap = new HashMap<>();
+
+    for (int i = 0; i < nums.length; i++) {
+      int num = nums[i];
+      int diff = target - num;
+
+      if (prevMap.containsKey(nums[i])) {
+        return new int[] { prevMap.get(num), i };
+      }
+
+      prevMap.put(target - num, i);
     }
-}
+
+    return new int[] {};
+  }
+}

java/100-Same-Tree.java

@@ -16,25 +16,25 @@
  * }
  */
 class Solution {
-    public boolean isSameTree(TreeNode p, TreeNode q) {
-        return dfs(p, q);
+
+  public boolean isSameTree(TreeNode p, TreeNode q) {
+    return dfs(p, q);
+  }
+
+  private boolean dfs(TreeNode p, TreeNode q) {
+    if (p == null && q == null) {
+      return true;
     }
-    
-    private boolean dfs(TreeNode p, TreeNode q) {
-        if (p == null && q == null) {
-            return true;
-        }
-        
-        if (p == null || q == null) {
-            return false;
-        }
-        
-        if (p.val != q.val) return false;
-        
-        boolean left = dfs(p.left, q.left);
-        boolean right = dfs(p.right, q.right);
-        
-        return left && right;
+
+    if (p == null || q == null) {
+      return false;
     }
-}
 
+    if (p.val != q.val) return false;
+
+    boolean left = dfs(p.left, q.left);
+    boolean right = dfs(p.right, q.right);
+
+    return left && right;
+  }
+}

java/102-Binary-Tree-Level-Order-Traversal.java

@@ -14,28 +14,29 @@
  * }
  */
 class Solution {
-    public List<List<Integer>> levelOrder(TreeNode root) {
-        List<List<Integer>> res = new ArrayList<>();
-        Queue<TreeNode> queue = new LinkedList<>();
-        
-        if (root == null) return res;
-        
-        queue.add(root);
-        while(!queue.isEmpty()) {
-            int len = queue.size();
-            List<Integer> level = new ArrayList<>();
-            for (int i = 0; i < len; i++) {
-                TreeNode curr = queue.poll();
-                level.add(curr.val);
-                if (curr.left != null) {
-                    queue.add(curr.left);
-                }
-                if (curr.right != null) {
-                    queue.add(curr.right);
-                }
-            }
-            res.add(level);
+
+  public List<List<Integer>> levelOrder(TreeNode root) {
+    List<List<Integer>> res = new ArrayList<>();
+    Queue<TreeNode> queue = new LinkedList<>();
+
+    if (root == null) return res;
+
+    queue.add(root);
+    while (!queue.isEmpty()) {
+      int len = queue.size();
+      List<Integer> level = new ArrayList<>();
+      for (int i = 0; i < len; i++) {
+        TreeNode curr = queue.poll();
+        level.add(curr.val);
+        if (curr.left != null) {
+          queue.add(curr.left);
         }
-        return res;
+        if (curr.right != null) {
+          queue.add(curr.right);
+        }
+      }
+      res.add(level);
     }
+    return res;
+  }
 }

java/104-Maximum-Depth-of-Binary-Tree.java

@@ -1,6 +1,7 @@
 class Solution {
-    public int maxDepth(TreeNode root) {
-        if (root == null) return 0;
-        return 1+Math.max(maxDepth(root.left), maxDepth(root.right));
-    }
+
+  public int maxDepth(TreeNode root) {
+    if (root == null) return 0;
+    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
+  }
 }

java/1046-Last-Stone-Weight.java

@@ -1,14 +1,13 @@
 class Solution {
-    public int lastStoneWeight(int[] stones) {
-        PriorityQueue<Integer> maxHeap = new PriorityQueue();
-        for (int stone: stones) 
-            maxHeap.add(-stone);
-        while (maxHeap.size()>1) {
-            int stone1 = maxHeap.remove();
-            int stone2 = maxHeap.remove();
-            if (stone1!=stone2) 
-                maxHeap.add(stone1-stone2);
-        }
-        return maxHeap.size()!=0?(-maxHeap.remove()):0;
+
+  public int lastStoneWeight(int[] stones) {
+    PriorityQueue<Integer> maxHeap = new PriorityQueue();
+    for (int stone : stones) maxHeap.add(-stone);
+    while (maxHeap.size() > 1) {
+      int stone1 = maxHeap.remove();
+      int stone2 = maxHeap.remove();
+      if (stone1 != stone2) maxHeap.add(stone1 - stone2);
     }
+    return maxHeap.size() != 0 ? (-maxHeap.remove()) : 0;
+  }
 }

java/105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.java

@@ -14,48 +14,69 @@
  * }
  */
 class Solution {
-    public TreeNode buildTree(int[] preorder, int[] inorder) {
-        if (preorder.length == 0 || inorder.length == 0) return null;
-        
-        TreeNode root = new TreeNode(preorder[0]);
-        int mid = 0;
-        for (int i = 0; i < inorder.length; i++) {
-            if (preorder[0] == inorder[i]) mid = i;
-        }
-        
-        root.left = buildTree(Arrays.copyOfRange(preorder, 1, mid + 1), Arrays.copyOfRange(inorder, 0, mid));
-        root.right = buildTree(Arrays.copyOfRange(preorder, mid + 1, preorder.length), Arrays.copyOfRange(inorder, mid + 1, inorder.length));
-        
-        return root;
+
+  public TreeNode buildTree(int[] preorder, int[] inorder) {
+    if (preorder.length == 0 || inorder.length == 0) return null;
+
+    TreeNode root = new TreeNode(preorder[0]);
+    int mid = 0;
+    for (int i = 0; i < inorder.length; i++) {
+      if (preorder[0] == inorder[i]) mid = i;
     }
+
+    root.left =
+      buildTree(
+        Arrays.copyOfRange(preorder, 1, mid + 1),
+        Arrays.copyOfRange(inorder, 0, mid)
+      );
+    root.right =
+      buildTree(
+        Arrays.copyOfRange(preorder, mid + 1, preorder.length),
+        Arrays.copyOfRange(inorder, mid + 1, inorder.length)
+      );
+
+    return root;
+  }
 }
 
 // Solution without using Array copies
 class Solution {
 
-    Map<Integer, Integer> inorderPositions = new HashMap<>();
+  Map<Integer, Integer> inorderPositions = new HashMap<>();
 
-    public TreeNode buildTree(int[] preorder, int[] inorder) {
-        if(preorder.length < 1 || inorder.length < 1) return null;
+  public TreeNode buildTree(int[] preorder, int[] inorder) {
+    if (preorder.length < 1 || inorder.length < 1) return null;
 
-        for(int i = 0; i < inorder.length; i ++) {
-            inorderPositions.put(inorder[i], i);
-        }
-
-        return builder(preorder, 0, 0, inorder.length-1);
+    for (int i = 0; i < inorder.length; i++) {
+      inorderPositions.put(inorder[i], i);
     }
 
-    public TreeNode builder(int[] preorder, int preorderIndex, int inorderLow, int inorderHigh) {
-        if (preorderIndex > preorder.length-1 || inorderLow > inorderHigh) return null;
+    return builder(preorder, 0, 0, inorder.length - 1);
+  }
 
-        int currentVal = preorder[preorderIndex];
-        TreeNode n = new TreeNode(currentVal);
-        int mid = inorderPositions.get(currentVal);
+  public TreeNode builder(
+    int[] preorder,
+    int preorderIndex,
+    int inorderLow,
+    int inorderHigh
+  ) {
+    if (
+      preorderIndex > preorder.length - 1 || inorderLow > inorderHigh
+    ) return null;
 
-        n.left = builder(preorder, preorderIndex+1, inorderLow, mid-1);
-        n.right = builder(preorder, preorderIndex + (mid - inorderLow) + 1, mid+1, inorderHigh);
+    int currentVal = preorder[preorderIndex];
+    TreeNode n = new TreeNode(currentVal);
+    int mid = inorderPositions.get(currentVal);
 
-        return n;
-    }
+    n.left = builder(preorder, preorderIndex + 1, inorderLow, mid - 1);
+    n.right =
+      builder(
+        preorder,
+        preorderIndex + (mid - inorderLow) + 1,
+        mid + 1,
+        inorderHigh
+      );
 
-}
+    return n;
+  }
+}

java/106-Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal.java

@@ -1,24 +1,58 @@
 //This video helped https://www.youtube.com/watch?v=LgLRTaEMRVc&ab_channel=takeUforward
 
 class Solution {
-    public TreeNode buildTree(int[] inorder, int[] postorder) {
-        HashMap<Integer, Integer> inMap = new HashMap<>();
-        for (int i = 0; i<inorder.length; i++) {
-            inMap.put(inorder[i],i);
-        }
-        return helper(inorder, 0, inorder.length-1, postorder,0, postorder.length-1, inMap);
+
+  public TreeNode buildTree(int[] inorder, int[] postorder) {
+    HashMap<Integer, Integer> inMap = new HashMap<>();
+    for (int i = 0; i < inorder.length; i++) {
+      inMap.put(inorder[i], i);
     }
-    
-    public TreeNode helper(int[] inorder, int iStart, int iEnd, int[] postorder, int pStart, int pEnd, HashMap<Integer, Integer> inMap) {
-        if (pStart>pEnd || iStart>iEnd) {
-            return null;
-        }
-        TreeNode root = new TreeNode(postorder[pEnd]);
-        int index = inMap.get(postorder[pEnd]);
-        int numsLeft = index-iStart;
-        root.left = helper(inorder, iStart, index-1, postorder, pStart, pStart+numsLeft-1, inMap);
-        root.right = helper(inorder, index+1, iEnd, postorder, pStart+numsLeft, pEnd-1, inMap);
-        return root;
+    return helper(
+      inorder,
+      0,
+      inorder.length - 1,
+      postorder,
+      0,
+      postorder.length - 1,
+      inMap
+    );
+  }
+
+  public TreeNode helper(
+    int[] inorder,
+    int iStart,
+    int iEnd,
+    int[] postorder,
+    int pStart,
+    int pEnd,
+    HashMap<Integer, Integer> inMap
+  ) {
+    if (pStart > pEnd || iStart > iEnd) {
+      return null;
     }
-    
+    TreeNode root = new TreeNode(postorder[pEnd]);
+    int index = inMap.get(postorder[pEnd]);
+    int numsLeft = index - iStart;
+    root.left =
+      helper(
+        inorder,
+        iStart,
+        index - 1,
+        postorder,
+        pStart,
+        pStart + numsLeft - 1,
+        inMap
+      );
+    root.right =
+      helper(
+        inorder,
+        index + 1,
+        iEnd,
+        postorder,
+        pStart + numsLeft,
+        pEnd - 1,
+        inMap
+      );
+    return root;
+  }
 }

java/107-Binary-Tree-Level-Order-Traversal-II.java

@@ -1,26 +1,27 @@
-//Same just reverse in the end. 
+//Same just reverse in the end.
 //Reversing in the end is better than using add(0, E) in case of arraylist as it's an O(1) operation.
 
 class Solution {
-    public List<List<Integer>> levelOrderBottom(TreeNode root) {
-        List<List<Integer>> ans = new ArrayList<>();
-        if (root == null) return ans;
-        Queue<TreeNode> q = new LinkedList<>();
-        q.offer(root);
-        while (!q.isEmpty()) {
-            List<Integer> level = new ArrayList<>();
-            int size = q.size();
-            for (int i = 0; i<size; i++) {
-                TreeNode cur = q.poll();
-                level.add(cur.val);
-                if (cur.left!=null) q.offer(cur.left);
-                if (cur.right!=null) q.offer(cur.right);
-            }
-            ans.add(level);
-        }
-        int i = 0 , j = ans.size()-1;
-        //reverse the list
-        Collections.reverse(ans);
-        return ans;
+
+  public List<List<Integer>> levelOrderBottom(TreeNode root) {
+    List<List<Integer>> ans = new ArrayList<>();
+    if (root == null) return ans;
+    Queue<TreeNode> q = new LinkedList<>();
+    q.offer(root);
+    while (!q.isEmpty()) {
+      List<Integer> level = new ArrayList<>();
+      int size = q.size();
+      for (int i = 0; i < size; i++) {
+        TreeNode cur = q.poll();
+        level.add(cur.val);
+        if (cur.left != null) q.offer(cur.left);
+        if (cur.right != null) q.offer(cur.right);
+      }
+      ans.add(level);
     }
+    int i = 0, j = ans.size() - 1;
+    //reverse the list
+    Collections.reverse(ans);
+    return ans;
+  }
 }