Merge pull request #1020 from abckhush/main

Added LC solution 94 & 96

Author: ajay-dhangar

dsa-solutions/lc-solutions/0000-0099/0094-Binary-Tree-Inorder-Traversal.md

@@ -0,0 +1,118 @@
+---
+id: binary-tree-inorder-traversal
+title: Binary Tree Inorder Traversal
+difficulty: Easy
+sidebar_label: 0094-Binary Tree Inorder Traversal
+tags:
+  - Binary Tree
+  - Inorder
+  - Traversal
+  - LeetCode Easy
+---
+
+## Problem
+
+| Problem Statement | Solution Link | LeetCode Profile |
+| :---------------- | :------------ | :--------------- |
+| [Binary Tree Inorder Traversal ](https://leetcode.com/problems/binary-tree-inorder-traversal/) | [Binary Tree Inorder Traversal Solution on LeetCode](https://leetcode.com/problems/solutions/) |  [Khushi Kalra](https://leetcode.com/u/abckhush/) |
+
+## Problem Description
+Given the root of a binary tree, return the inorder traversal of its nodes' values.
+### Example
+**Example 1:**
+```plaintext
+Input: root = [1,null,2,3]
+Output: [1,3,2]
+```
+**Example 2:**
+```plaintext
+Input: root = []
+Output: []
+```
+**Example 3:**
+```plaintext
+Input: root = [1]
+Output: [1]
+```
+
+### Constraints
+1. The number of nodes in the tree is in the range `[0, 100]`.
+2. `-100 <= Node.val <= 100`
+ 
+## Approach: Recursion
+The problem is to perform an inorder traversal of a binary tree and return the values in a list. An inorder traversal visits the nodes of the binary tree in the following order: left subtree, root node, right subtree.
+
+We use a helper function traversal to perform the inorder traversal recursively. The main function inorderTraversal initializes the result list and calls the helper function.
+
+1. Initialization:
+- Create an empty vector inOrder to store the result of the inorder traversal.
+
+2. Recursive Traversal:
+- Define a helper function traversal that takes a TreeNode* and a reference to the inOrder vector.
+- If the current node (root) is NULL, return immediately (base case).
+- Recursively call traversal on the left subtree (root->left).
+- Push the value of the current node (root->val) to the inOrder vector.
+- Recursively call traversal on the right subtree (root->right).
+
+3. Main Function:
+- In the inorderTraversal function, create an empty vector inOrder.
+- Call the traversal function with the root of the binary tree and the inOrder vector.
+- Return the inOrder vector containing the inorder traversal result.
+
+## Complexity
+1. Time Complexity : $$O(h)$$
+2. Space Complexity : $$O(n)$$
+
+## Code
+
+### C++
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    void traversal(TreeNode* root, vector<int>&inOrder){
+        if(root==NULL) return;
+        traversal(root->left, inOrder);
+        inOrder.push_back(root->val);
+        traversal(root->right, inOrder);
+    }
+    vector<int> inorderTraversal(TreeNode* root) {
+        vector<int>inOrder;
+        traversal(root, inOrder);
+        return inOrder;
+    }
+};
+```
+
+### Python
+```python
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def traversal(self, root, inOrder):
+        if root is None:
+            return
+        self.traversal(root.left, inOrder)
+        inOrder.append(root.val)
+        self.traversal(root.right, inOrder)
+    
+    def inorderTraversal(self, root):
+        inOrder = []
+        self.traversal(root, inOrder)
+        return inOrder
+```

dsa-solutions/lc-solutions/0000-0099/0096-Unique-Binary-Search-Trees.md

@@ -0,0 +1,115 @@
+---
+id: unique-binary-search-tree
+title: Unique Binary Search Tree
+difficulty: Medium
+sidebar_label: 0096- Unique Binary Search Tree
+tags:
+  - Binary Search Tree
+  - LeetCode Medium
+---
+
+## Problem
+
+| Problem Statement | Solution Link | LeetCode Profile |
+| :---------------- | :------------ | :--------------- |
+| [Unique Binary Search Tree ](https://leetcode.com/problems/unique-binary-search-trees/description/) | [Unique Binary Search Tree Solution on LeetCode](https://leetcode.com/problems/unique-binary-search-trees/solutions/4945144/easy-recursion-dynamic-programming-c-solution-beats-100) |  [Khushi Kalra](https://leetcode.com/u/abckhush/) |
+
+## Problem Description
+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.
+
+### Examples
+**Example 1:**
+```plaintext
+Input: n = 3
+Output: 5
+```
+**Example 2:**
+```plaintext
+Input: n = 1
+Output: 1
+```
+ 
+### Constraints:
+`1 <= n <= 19`
+
+## Approach#1 : RECURSION 
+We use a recursive function numTrees(n) where numTrees(n) returns the number of unique BSTs that can be formed with n nodes. The following steps outline the approach:
+
+1. Base Cases:
+If n is 0 or 1, return 1. There is exactly one unique BST that can be formed with 0 or 1 nodes:
+- numTrees(0) = 1: An empty tree is considered one unique BST.
+- numTrees(1) = 1: A single-node tree is also one unique BST.
+
+2. Recursive Calculation:
+- Initialize count to 0. This variable will accumulate the total number of unique BSTs for n nodes.
+- For each i from 1 to n, consider i as the root of the BST:
+    - The left subtree will have i-1 nodes.
+    - The right subtree will have n-i nodes.
+- The total number of unique BSTs with i as the root is the product of the number of unique BSTs for the left and right subtrees.
+- Accumulate the results in count by adding the product of the number of unique BSTs for the left and right subtrees:
+`count += numTrees(i-1) * numTrees(n-i)`
+
+3. Return the Result:
+- After computing the total count for all possible roots from 1 to n, return count.
+
+### Complexity
+1. Time complexity: $$O(2^n)$$ 
+2. Space complexity: $$O(n)$$
+
+### Code
+```cpp
+class Solution {
+public:
+    int numTrees(int n) {
+        if(n==0 || n==1) return 1;
+        int count=0;
+        for(int i=1; i<=n; i++){
+            count= count + (numTrees(i-1)*numTrees(n-i));
+        }
+        return count;
+    }
+};
+```
+
+## Approach#2: DYNAMIC PROGRAMMING
+We use a dynamic programming array dp where dp[i] represents the number of unique BSTs that can be formed with i nodes. The following steps outline the approach:
+
+1. Initialization:
+- Create a dynamic programming array dp of size n+1 initialized with zeros.
+- Set the base cases:
+    - dp[0] = 1: An empty tree is considered one unique BST.
+    - dp[1] = 1: A single-node tree is also one unique BST.
+
+2. Filling the DP Array:
+- Iterate over the number of nodes from 2 to n (let's call this i).
+- For each i, consider each node j (from 1 to i) as the root of the BST.
+- The number of unique BSTs with i nodes can be computed as the sum of all possible left and right subtrees:
+- The left subtree will have j-1 nodes.
+- The right subtree will have i-j nodes.
+- Update the dp[i] value as the sum of the products of the number of unique BSTs for the left and right subtrees:
+`dp[i] += dp[j-1] * dp[i-j]`
+
+3. Return the Result:
+- After filling the dp array, dp[n] will contain the number of unique BSTs that can be formed with n nodes.
+
+### Complexity
+1. Time complexity: $$O(n^2)$$
+2. Space complexity: $$O(n)$$
+
+### Code
+```cpp
+class Solution {
+public:
+    int numTrees(int n) {
+        vector<int>dp(n+1, 0);
+        dp[0]=1;
+        dp[1]=1;
+        for(int i=2; i<=n; i++){
+            for(int j=1; j<=i; j++){
+                dp[i]= dp[i]+ dp[i-j]*dp[j-1];
+            }
+        }
+        return dp[n];
+    }
+};
+```