Added cpp tasks 96-155

Author: javadev

src/main/cpp/g0001_0100/s0096_unique_binary_search_trees/readme.md

@@ -0,0 +1,56 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 96\. Unique Binary Search Trees
+
+Medium
+
+Given an integer `n`, return _the number of structurally unique **BST'**s (binary search trees) which has exactly_ `n` _nodes of unique values from_ `1` _to_ `n`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg)
+
+**Input:** n = 3
+
+**Output:** 5 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `1 <= n <= 19`
+
+To solve the "Unique Binary Search Trees" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `numTrees` in the `Solution` class that takes an integer `n` as input and returns the number of structurally unique BSTs (binary search trees) with exactly `n` nodes.
+2. Implement a dynamic programming approach to solve the problem:
+   - Create an array `dp` of size `n + 1` to store the number of unique BSTs for each number of nodes from 0 to `n`.
+   - Initialize `dp[0] = 1` and `dp[1] = 1`, as there is only one unique BST for 0 and 1 node(s).
+   - Use a nested loop to calculate `dp[i]` for each `i` from 2 to `n`.
+   - For each `i`, calculate `dp[i]` by summing up the products of `dp[j]` and `dp[i - j - 1]` for all possible values of `j` from 0 to `i - 1`.
+   - Return `dp[n]`, which represents the number of unique BSTs with `n` nodes.
+
+Here's the implementation of the `numTrees` method in Java:
+
+```java
+class Solution {
+    public int numTrees(int n) {
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+        dp[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            for (int j = 0; j < i; j++) {
+                dp[i] += dp[j] * dp[i - j - 1];
+            }
+        }
+        return dp[n];
+    }
+}
+```
+
+This implementation uses dynamic programming to compute the number of structurally unique BSTs with `n` nodes in O(n^2) time complexity.

src/main/cpp/g0001_0100/s0098_validate_binary_search_tree/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 98\. Validate Binary Search Tree
+
+Medium
+
+Given the `root` of a binary tree, _determine if it is a valid binary search tree (BST)_.
+
+A **valid BST** is defined as follows:
+
+*   The left subtree of a node contains only nodes with keys **less than** the node's key.
+*   The right subtree of a node contains only nodes with keys **greater than** the node's key.
+*   Both the left and right subtrees must also be binary search trees.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/01/tree1.jpg)
+
+**Input:** root = [2,1,3]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/01/tree2.jpg)
+
+**Input:** root = [5,1,4,null,null,3,6]
+
+**Output:** false
+
+**Explanation:** The root node's value is 5 but its right child's value is 4. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.
+*   <code>-2<sup>31</sup> <= Node.val <= 2<sup>31</sup> - 1</code>
+
+To solve the "Validate Binary Search Tree" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `isValidBST` in the `Solution` class that takes the root of a binary tree as input and returns true if the tree is a valid binary search tree (BST), and false otherwise.
+2. Implement a recursive approach to validate if the given binary tree is a valid BST:
+   - Define a helper method `isValidBSTHelper` that takes the root node, a lower bound, and an upper bound as input parameters.
+   - In the `isValidBSTHelper` method, recursively traverse the binary tree nodes.
+   - At each node, check if its value is within the specified bounds (lower bound and upper bound) for a valid BST.
+   - If the node's value violates the BST property, return false.
+   - Otherwise, recursively validate the left and right subtrees by updating the bounds accordingly.
+   - If both the left and right subtrees are valid BSTs, return true.
+3. Call the `isValidBSTHelper` method with the root node and appropriate initial bounds to start the validation process.
+
+Here's the implementation of the `isValidBST` method in Java:
+
+```java
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        return isValidBSTHelper(root, null, null);
+    }
+    
+    private boolean isValidBSTHelper(TreeNode node, Integer lower, Integer upper) {
+        if (node == null) {
+            return true;
+        }
+        
+        int val = node.val;
+        if ((lower != null && val <= lower) || (upper != null && val >= upper)) {
+            return false;
+        }
+        
+        return isValidBSTHelper(node.left, lower, val) && isValidBSTHelper(node.right, val, upper);
+    }
+}
+```
+
+This implementation recursively validates whether the given binary tree is a valid BST in O(n) time complexity, where n is the number of nodes in the tree.

src/main/cpp/g0101_0200/s0101_symmetric_tree/readme.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 101\. Symmetric Tree
+
+Easy
+
+Given the `root` of a binary tree, _check whether it is a mirror of itself_ (i.e., symmetric around its center).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/symtree1.jpg)
+
+**Input:** root = [1,2,2,3,4,4,3]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/symtree2.jpg)
+
+**Input:** root = [1,2,2,null,3,null,3]
+
+**Output:** false 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `-100 <= Node.val <= 100`
+
+**Follow up:** Could you solve it both recursively and iteratively?
+
+To solve the "Symmetric Tree" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `isSymmetric` in the `Solution` class that takes the root of a binary tree as input and returns true if the tree is symmetric, and false otherwise.
+2. Implement a recursive approach to check if the given binary tree is symmetric:
+   - Define a helper method `isMirror` that takes two tree nodes as input parameters.
+   - In the `isMirror` method, recursively compare the left and right subtrees of the given nodes.
+   - At each step, check if the values of the corresponding nodes are equal and if the left subtree of one node is a mirror image of the right subtree of the other node.
+   - If both conditions are satisfied for all corresponding nodes, return true; otherwise, return false.
+3. Call the `isMirror` method with the root's left and right children to check if the entire tree is symmetric.
+
+Here's the implementation of the `isSymmetric` method in Java:
+
+```java
+class Solution {
+    public boolean isSymmetric(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        return isMirror(root.left, root.right);
+    }
+    
+    private boolean isMirror(TreeNode left, TreeNode right) {
+        if (left == null && right == null) {
+            return true;
+        }
+        if (left == null || right == null) {
+            return false;
+        }
+        return (left.val == right.val) && isMirror(left.left, right.right) && isMirror(left.right, right.left);
+    }
+}
+```
+
+This implementation recursively checks whether the given binary tree is symmetric around its center in O(n) time complexity, where n is the number of nodes in the tree.

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

@@ -0,0 +1,105 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 102\. Binary Tree Level Order Traversal
+
+Medium
+
+Given the `root` of a binary tree, return _the level order traversal of its nodes' values_. (i.e., from left to right, level by level).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** [[3],[9,20],[15,7]] 
+
+**Example 2:**
+
+**Input:** root = [1]
+
+**Output:** [[1]] 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 2000]`.
+*   `-1000 <= Node.val <= 1000`
+
+To solve the "Binary Tree Level Order Traversal" problem in Java with a `Solution` class, we'll perform a breadth-first search (BFS) traversal of the binary tree. 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. **Initialize a queue**: Create a queue to store the nodes during BFS traversal.
+
+4. **Check for null root**: Check if the root is null. If it is, return an empty list.
+
+5. **Perform BFS traversal**: Enqueue the root node into the queue. While the queue is not empty:
+   - Dequeue the front node from the queue.
+   - Add the value of the dequeued node to the current level list.
+   - Enqueue the left and right children of the dequeued node if they exist.
+   - Move to the next level when all nodes in the current level are processed.
+
+6. **Return the result**: After the BFS traversal is complete, return the list containing the level order traversal of the binary tree.
+
+Here's the Java implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>(); // Initialize list to store level order traversal
+        if (root == null) return result; // Check for empty tree
+        
+        Queue<TreeNode> queue = new LinkedList<>(); // Initialize queue for BFS traversal
+        queue.offer(root); // Enqueue the root node
+        
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size(); // Get the number of nodes in the current level
+            List<Integer> level = new ArrayList<>(); // Initialize list for the current level
+            
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode node = queue.poll(); // Dequeue the front node
+                level.add(node.val); // Add node value to the current level list
+                
+                // Enqueue the left and right children if they exist
+                if (node.left != null) queue.offer(node.left);
+                if (node.right != null) queue.offer(node.right);
+            }
+            
+            result.add(level); // Add the current level list to the result list
+        }
+        
+        return result; // Return the level order traversal
+    }
+    
+    // Definition for a TreeNode
+    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 computes the level order traversal of the binary tree in Java using BFS.

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

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 104\. Maximum Depth of Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, return _its maximum depth_.
+
+A binary tree's **maximum depth** is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** 3 
+
+**Example 2:**
+
+**Input:** root = [1,null,2]
+
+**Output:** 2 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** 0 
+
+**Example 4:**
+
+**Input:** root = [0]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   `-100 <= Node.val <= 100`
+
+To solve the "Maximum Depth of Binary Tree" problem in Java with a `Solution` class, we'll perform a depth-first search (DFS) traversal of the binary tree. 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 it is, return 0 as the depth.
+
+4. **Perform DFS traversal**: Recursively compute the depth of the left and right subtrees. The maximum depth of the binary tree is the maximum depth of its left and right subtrees, plus 1 for the current node.
+
+5. **Return the result**: After the DFS traversal is complete, return the maximum depth of the binary tree.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) return 0; // Check for empty tree
+        int leftDepth = maxDepth(root.left); // Compute depth of left subtree
+        int rightDepth = maxDepth(root.right); // Compute depth of right subtree
+        return Math.max(leftDepth, rightDepth) + 1; // Return maximum depth of left and right subtrees, plus 1 for the current node
+    }
+    
+    // Definition for a TreeNode
+    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 computes the maximum depth of the binary tree in Java using DFS traversal.