Added solutions 102-138

Author: javadev

src/main/java/g0101_0200/s0102_binary_tree_level_order_traversal/readme.md

@@ -27,4 +27,77 @@ Given the `root` of a binary tree, return _the level order traversal of its node
 **Constraints:**
 
 *   The number of nodes in the tree is in the range `[0, 2000]`.
-*   `-1000 <= Node.val <= 1000`
+*   `-1000 <= Node.val <= 1000`
+
+To solve this problem in Java with a `Solution` class, we'll use a breadth-first search (BFS) traversal approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `levelOrder` method**: This method takes the root node of the binary tree as input and returns the level order traversal of its nodes' values.
+
+3. **Check for null root**: Check if the root is null. If so, return an empty list since there are no nodes to traverse.
+
+4. **Initialize a queue**: We'll use a queue to perform BFS traversal. Add the root node to the queue.
+
+5. **Traverse the tree level by level**:
+   - Start a loop that continues until the queue is empty.
+   - Inside the loop, for each level, get the size of the queue (number of nodes at the current level).
+   - Create a list to store the node values at the current level.
+   - Iterate through all nodes at the current level:
+     - Poll a node from the queue.
+     - Add its value to the list.
+     - If the node has left or right children, add them to the queue.
+   - After processing all nodes at the current level, add the list of node values to the result list.
+
+6. **Return the result**: After traversing the entire tree, return the result containing the level order traversal.
+
+Here's the Java implementation:
+
+```java
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        
+        if (root == null) return result; // Check for empty tree
+        
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root); // Add root to the queue
+        
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size(); // Get the number of nodes at the current level
+            List<Integer> levelNodes = new ArrayList<>(); // List to store node values at current level
+            
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode node = queue.poll(); // Remove node from the queue
+                levelNodes.add(node.val); // Add its value to the list
+                
+                // Add left and right children to the queue if they exist
+                if (node.left != null) queue.offer(node.left);
+                if (node.right != null) queue.offer(node.right);
+            }
+            result.add(levelNodes); // Add list of node values at current level to result
+        }
+        
+        return result;
+    }
+    
+    // TreeNode definition
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        
+        TreeNode() {}
+        TreeNode(int val) { this.val = val; }
+        TreeNode(int val, TreeNode left, TreeNode right) {
+            this.val = val;
+            this.left = left;
+            this.right = right;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently solves the problem of binary tree level order traversal in Java.

src/main/java/g0101_0200/s0104_maximum_depth_of_binary_tree/readme.md

@@ -35,4 +35,55 @@ A binary tree's **maximum depth** is the number of nodes along the longest path
 **Constraints:**
 
 *   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
-*   `-100 <= Node.val <= 100`
+*   `-100 <= Node.val <= 100`
+
+To solve this problem in Java with a `Solution` class, we'll use a depth-first search (DFS) traversal approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `maxDepth` method**: This method takes the root node of the binary tree as input and returns its maximum depth.
+
+3. **Check for null root**: Check if the root is null. If so, return 0, as an empty tree has a maximum depth of 0.
+
+4. **Recursively calculate the maximum depth**: Define a helper method `dfs` to recursively calculate the maximum depth of the binary tree.
+   - If the current node is null, return 0.
+   - Otherwise, recursively calculate the maximum depth of the left and right subtrees.
+   - Return the maximum depth of the left and right subtrees, plus 1 (to account for the current node).
+
+5. **Return the maximum depth**: After traversing the entire tree, return the maximum depth calculated.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) return 0; // Check for empty tree
+        return dfs(root); // Recursively calculate maximum depth
+    }
+    
+    // Helper method to recursively calculate maximum depth
+    private int dfs(TreeNode node) {
+        if (node == null) return 0;
+        int leftDepth = dfs(node.left); // Calculate maximum depth of left subtree
+        int rightDepth = dfs(node.right); // Calculate maximum depth of right subtree
+        return Math.max(leftDepth, rightDepth) + 1; // Return maximum depth plus 1 for current node
+    }
+    
+    // TreeNode definition
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        
+        TreeNode() {}
+        TreeNode(int val) { this.val = val; }
+        TreeNode(int val, TreeNode left, TreeNode right) {
+            this.val = val;
+            this.left = left;
+            this.right = right;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently solves the problem of finding the maximum depth of a binary tree in Java.

src/main/java/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/readme.md

@@ -26,4 +26,80 @@ Given two integer arrays `preorder` and `inorder` where `preorder` is the preord
 *   `preorder` and `inorder` consist of **unique** values.
 *   Each value of `inorder` also appears in `preorder`.
 *   `preorder` is **guaranteed** to be the preorder traversal of the tree.
-*   `inorder` is **guaranteed** to be the inorder traversal of the tree.
+*   `inorder` is **guaranteed** to be the inorder traversal of the tree.
+
+To solve the "Construct Binary Tree from Preorder and Inorder Traversal" problem in Java with a `Solution` class, we'll use a recursive approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `buildTree` method**: This method takes two integer arrays, `preorder` and `inorder`, as input and returns the constructed binary tree.
+
+3. **Check for empty arrays**: Check if either of the arrays `preorder` or `inorder` is empty. If so, return null, as there's no tree to construct.
+
+4. **Define a helper method**: Define a recursive helper method `build` to construct the binary tree.
+   - The method should take the indices representing the current subtree in both `preorder` and `inorder`.
+   - The start and end indices in `preorder` represent the current subtree's preorder traversal.
+   - The start and end indices in `inorder` represent the current subtree's inorder traversal.
+   
+5. **Base case**: If the start index of `preorder` is greater than the end index or if the start index of `inorder` is greater than the end index, return null.
+
+6. **Find the root node**: The root node is the first element in the `preorder` array.
+
+7. **Find the root's position in `inorder`**: Iterate through the `inorder` array to find the root's position.
+
+8. **Recursively build left and right subtrees**: 
+   - Recursively call the `build` method for the left subtree with updated indices.
+   - Recursively call the `build` method for the right subtree with updated indices.
+   
+9. **Return the root node**: After constructing the left and right subtrees, return the root node.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        if (preorder.length == 0 || inorder.length == 0) return null; // Check for empty arrays
+        return build(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1); // Construct binary tree
+    }
+    
+    // Recursive helper method to construct binary tree
+    private TreeNode build(int[] preorder, int[] inorder, int preStart, preEnd, int inStart, int inEnd) {
+        if (preStart > preEnd || inStart > inEnd) return null; // Base case
+        
+        int rootValue = preorder[preStart]; // Root node value
+        TreeNode root = new TreeNode(rootValue); // Create root node
+        
+        // Find root node's position in inorder array
+        int rootIndex = 0;
+        for (int i = inStart; i <= inEnd; i++) {
+            if (inorder[i] == rootValue) {
+                rootIndex = i;
+                break;
+            }
+        }
+        
+        // Recursively build left and right subtrees
+        root.left = build(preorder, inorder, preStart + 1, preStart + rootIndex - inStart, inStart, rootIndex - 1);
+        root.right = build(preorder, inorder, preStart + rootIndex - inStart + 1, preEnd, rootIndex + 1, inEnd);
+        
+        return root; // Return root node
+    }
+    
+    // TreeNode definition
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        
+        TreeNode() {}
+        TreeNode(int val) { this.val = val; }
+        TreeNode(int val, TreeNode left, TreeNode right) {
+            this.val = val;
+            this.left = left;
+            this.right = right;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently constructs the binary tree from preorder and inorder traversals in Java.

src/main/java/g0101_0200/s0114_flatten_binary_tree_to_linked_list/readme.md

@@ -32,4 +32,81 @@ Given the `root` of a binary tree, flatten the tree into a "linked list":
 *   The number of nodes in the tree is in the range `[0, 2000]`.
 *   `-100 <= Node.val <= 100`
 
-**Follow up:** Can you flatten the tree in-place (with `O(1)` extra space)?
+**Follow up:** Can you flatten the tree in-place (with `O(1)` extra space)?
+
+To solve the "Flatten Binary Tree to Linked List" problem in Java with a `Solution` class, we'll use a recursive approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `flatten` method**: This method takes the root node of the binary tree as input and flattens the tree into a linked list using preorder traversal.
+
+3. **Check for null root**: Check if the root is null. If so, there's no tree to flatten, so return.
+
+4. **Recursively flatten the tree**: Define a recursive helper method `flattenTree` to perform the flattening.
+   - The method should take the current node as input.
+   - Perform a preorder traversal of the tree.
+   - For each node, if it has a left child:
+     - Find the rightmost node in the left subtree.
+     - Attach the right subtree of the current node to the right of the rightmost node.
+     - Move the left subtree to the right subtree position.
+     - Set the left child of the current node to null.
+   - Recursively call the method for the right child.
+
+5. **Call the helper method**: Call the `flattenTree` method with the root node.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public void flatten(TreeNode root) {
+        if (root == null) return; // Check for empty tree
+        flattenTree(root); // Flatten the tree
+    }
+    
+    // Recursive helper method to flatten the tree
+    private void flattenTree(TreeNode node) {
+        if (node == null) return;
+        
+        // Flatten left subtree
+        flattenTree(node.left);
+        
+        // Flatten right subtree
+        flattenTree(node.right);
+        
+        // Save right subtree
+        TreeNode rightSubtree = node.right;
+        
+        // Attach left subtree to the right of the current node
+        node.right = node.left;
+        
+        // Set left child to null
+        node.left = null;
+        
+        // Move to the rightmost node of the flattened left subtree
+        TreeNode current = node;
+        while (current.right != null) {
+            current = current.right;
+        }
+        
+        // Attach the saved right subtree to the right of the rightmost node
+        current.right = rightSubtree;
+    }
+    
+    // TreeNode definition
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        
+        TreeNode() {}
+        TreeNode(int val) { this.val = val; }
+        TreeNode(int val, TreeNode left, TreeNode right) {
+            this.val = val;
+            this.left = left;
+            this.right = right;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently flattens the binary tree into a linked list using preorder traversal in Java.

src/main/java/g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md

@@ -27,4 +27,42 @@ Return _the maximum profit you can achieve from this transaction_. If you cannot
 **Constraints:**
 
 *   <code>1 <= prices.length <= 10<sup>5</sup></code>
-*   <code>0 <= prices[i] <= 10<sup>4</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>4</sup></code>
+
+To solve the "Best Time to Buy and Sell Stock" problem in Java with a `Solution` class, we'll use a greedy algorithm. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `maxProfit` method**: This method takes an array `prices` as input and returns the maximum profit that can be achieved by buying and selling the stock.
+
+3. **Initialize variables**: Initialize two variables, `minPrice` to store the minimum price seen so far and `maxProfit` to store the maximum profit seen so far. Initialize `maxProfit` to 0.
+
+4. **Iterate through the prices array**:
+   - For each price in the array:
+     - Update `minPrice` to the minimum of the current price and `minPrice`.
+     - Update `maxProfit` to the maximum of the current profit (price - `minPrice`) and `maxProfit`.
+
+5. **Return the maximum profit**: After iterating through the entire array, return `maxProfit`.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if (prices == null || prices.length <= 1) return 0; // Check for empty array or single element
+        
+        int minPrice = prices[0]; // Initialize minPrice to the first price
+        int maxProfit = 0; // Initialize maxProfit to 0
+        
+        // Iterate through the prices array
+        for (int i = 1; i < prices.length; i++) {
+            minPrice = Math.min(minPrice, prices[i]); // Update minPrice
+            maxProfit = Math.max(maxProfit, prices[i] - minPrice); // Update maxProfit
+        }
+        
+        return maxProfit; // Return the maximum profit
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently calculates the maximum profit that can be achieved by buying and selling the stock in Java.