Added tasks 105-141

Author: javadev

g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/readme.md

@@ -0,0 +1,83 @@
+105\. Construct Binary Tree from Preorder and Inorder Traversal
+
+Medium
+
+Given two integer arrays `preorder` and `inorder` where `preorder` is the preorder traversal of a binary tree and `inorder` is the inorder traversal of the same tree, construct and return _the binary tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg)
+
+**Input:** preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
+
+**Output:** [3,9,20,null,null,15,7] 
+
+**Example 2:**
+
+**Input:** preorder = [-1], inorder = [-1]
+
+**Output:** [-1] 
+
+**Constraints:**
+
+*   `1 <= preorder.length <= 3000`
+*   `inorder.length == preorder.length`
+*   `-3000 <= preorder[i], inorder[i] <= 3000`
+*   `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.
+
+To solve this task, we can use a recursive approach to construct the binary tree. We'll define a `Solution` class with a method `buildTree` to perform this task. Here are the steps:
+
+1. Define the `Solution` class.
+2. Define the `buildTree` method which takes `preorder` and `inorder` lists as input.
+3. Create a helper function, let's call it `buildTreeHelper`, that takes the indices representing the current subtree in preorder and inorder lists.
+4. In the `buildTreeHelper` function, if the `preorder` list is empty or the `inorder` list is empty, return `None`, indicating an empty subtree.
+5. Otherwise, the first element of the `preorder` list would be the root of the current subtree. Create a node for this root.
+6. Find the index of the root value in the `inorder` list. This index will partition the `inorder` list into left and right subtrees.
+7. Recursively call `buildTreeHelper` for the left subtree with appropriate indices.
+8. Recursively call `buildTreeHelper` for the right subtree with appropriate indices.
+9. Return the root node.
+10. Call `buildTreeHelper` from the `buildTree` method with initial indices for the entire preorder and inorder lists.
+11. Return the root node obtained from `buildTreeHelper`.
+
+Here's the Python code implementing these steps:
+
+```python
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def buildTree(self, preorder, inorder):
+        if not preorder or not inorder:
+            return None
+        
+        def buildTreeHelper(pre_start, pre_end, in_start, in_end):
+            if pre_start > pre_end or in_start > in_end:
+                return None
+            
+            root_val = preorder[pre_start]
+            root = TreeNode(root_val)
+            
+            # Find index of root value in inorder list
+            root_index = inorder.index(root_val)
+            
+            # Calculate the number of nodes in the left subtree
+            left_subtree_size = root_index - in_start
+            
+            # Recursively build left subtree
+            root.left = buildTreeHelper(pre_start + 1, pre_start + left_subtree_size, in_start, root_index - 1)
+            
+            # Recursively build right subtree
+            root.right = buildTreeHelper(pre_start + left_subtree_size + 1, pre_end, root_index + 1, in_end)
+            
+            return root
+        
+        return buildTreeHelper(0, len(preorder) - 1, 0, len(inorder) - 1)
+```
+
+You can then use this `Solution` class to construct the binary tree from preorder and inorder traversal arrays.

g0101_0200/s0114_flatten_binary_tree_to_linked_list/readme.md

@@ -0,0 +1,80 @@
+114\. Flatten Binary Tree to Linked List
+
+Medium
+
+Given the `root` of a binary tree, flatten the tree into a "linked list":
+
+*   The "linked list" should use the same `TreeNode` class where the `right` child pointer points to the next node in the list and the `left` child pointer is always `null`.
+*   The "linked list" should be in the same order as a [**pre-order** **traversal**](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR) of the binary tree.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg)
+
+**Input:** root = [1,2,5,3,4,null,6]
+
+**Output:** [1,null,2,null,3,null,4,null,5,null,6] 
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** root = [0]
+
+**Output:** [0] 
+
+**Constraints:**
+
+*   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)?
+
+To solve this task, we can use a recursive approach to flatten the binary tree. We'll define a `Solution` class with a method `flatten` to perform this task. Here are the steps:
+
+1. Define the `Solution` class.
+2. Define the `flatten` method which takes `root` as input.
+3. Create a helper function, let's call it `flattenHelper`, that takes a node as input.
+4. In the `flattenHelper` function, if the current node is `None`, return `None`.
+5. Otherwise, recursively flatten the left subtree and right subtree.
+6. Once both subtrees are flattened, set the `right` child of the root to the flattened left subtree.
+7. Traverse to the end of the flattened left subtree and attach the flattened right subtree to its `right`.
+8. Set the `left` child of the root to `None`.
+9. Return the last node of the flattened tree (either the last node of the flattened right subtree or the last node of the flattened left subtree if the right subtree is `None`).
+10. Call `flattenHelper` from the `flatten` method with the root node.
+11. Return the root node.
+
+Here's the Python code implementing these steps:
+
+```python
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def flatten(self, root):
+        def flattenHelper(node):
+            if not node:
+                return None
+            
+            left_last = flattenHelper(node.left)
+            right_last = flattenHelper(node.right)
+            
+            if left_last:
+                left_last.right = node.right
+                node.right = node.left
+                node.left = None
+            
+            return right_last if right_last else left_last if left_last else node
+        
+        flattenHelper(root)
+        return root
+```
+
+You can then use this `Solution` class to flatten the binary tree into a linked list in pre-order traversal order.

g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md

@@ -0,0 +1,60 @@
+121\. Best Time to Buy and Sell Stock
+
+Easy
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+You want to maximize your profit by choosing a **single day** to buy one stock and choosing a **different day in the future** to sell that stock.
+
+Return _the maximum profit you can achieve from this transaction_. If you cannot achieve any profit, return `0`.
+
+**Example 1:**
+
+**Input:** prices = [7,1,5,3,6,4]
+
+**Output:** 5
+
+**Explanation:** Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell. 
+
+**Example 2:**
+
+**Input:** prices = [7,6,4,3,1]
+
+**Output:** 0
+
+**Explanation:** In this case, no transactions are done and the max profit = 0. 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>4</sup></code>
+
+To solve this task, we can use a greedy approach. We'll iterate through the prices array and keep track of the minimum price seen so far and the maximum profit we can achieve. Here are the steps:
+
+1. Define the `Solution` class.
+2. Define the `maxProfit` method which takes `prices` as input.
+3. Initialize variables `min_price` to store the minimum price seen so far and `max_profit` to store the maximum profit.
+4. Iterate through the `prices` array.
+5. Update `min_price` to the minimum of the current price and `min_price`.
+6. Update `max_profit` to the maximum of the difference between the current price and `min_price`, and `max_profit`.
+7. After iterating through the array, return `max_profit`.
+
+Here's the Python code implementing these steps:
+
+```python
+class Solution:
+    def maxProfit(self, prices):
+        if not prices or len(prices) == 1:
+            return 0
+        
+        min_price = prices[0]
+        max_profit = 0
+        
+        for price in prices[1:]:
+            min_price = min(min_price, price)
+            max_profit = max(max_profit, price - min_price)
+        
+        return max_profit
+```
+
+You can then use this `Solution` class to find the maximum profit you can achieve by buying and selling stocks.

g0101_0200/s0124_binary_tree_maximum_path_sum/readme.md

@@ -0,0 +1,79 @@
+124\. Binary Tree Maximum Path Sum
+
+Hard
+
+A **path** in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence **at most once**. Note that the path does not need to pass through the root.
+
+The **path sum** of a path is the sum of the node's values in the path.
+
+Given the `root` of a binary tree, return _the maximum **path sum** of any **non-empty** path_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg)
+
+**Input:** root = [1,2,3]
+
+**Output:** 6
+
+**Explanation:** The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg)
+
+**Input:** root = [-10,9,20,null,null,15,7]
+
+**Output:** 42
+
+**Explanation:** The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 3 * 10<sup>4</sup>]</code>.
+*   `-1000 <= Node.val <= 1000`
+
+To solve this task, we can use a recursive approach to traverse the binary tree and calculate the maximum path sum. We'll define a `Solution` class with a method `maxPathSum` to perform this task. Here are the steps:
+
+1. Define the `Solution` class.
+2. Define the `maxPathSum` method which takes `root` as input.
+3. Create a helper function, let's call it `maxPathSumHelper`, that takes a node as input.
+4. In the `maxPathSumHelper` function, if the current node is `None`, return `0`.
+5. Recursively calculate the maximum path sum for the left and right subtrees using `maxPathSumHelper`.
+6. Calculate the maximum path sum passing through the current node, considering the possibility of including both left and right subtrees.
+7. Update a global variable `max_sum` to keep track of the maximum path sum encountered so far.
+8. Return the maximum path sum that includes either the current node or just one of its subtrees (if the sum with both subtrees is negative).
+9. Call `maxPathSumHelper` from the `maxPathSum` method with the root node.
+10. Return the global variable `max_sum`.
+
+Here's the Python code implementing these steps:
+
+```python
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def maxPathSum(self, root):
+        def maxPathSumHelper(node):
+            if not node:
+                return 0
+            
+            left_sum = max(maxPathSumHelper(node.left), 0)
+            right_sum = max(maxPathSumHelper(node.right), 0)
+            
+            current_max = node.val + left_sum + right_sum
+            
+            global max_sum
+            max_sum = max(max_sum, current_max)
+            
+            return node.val + max(left_sum, right_sum)
+        
+        max_sum = float('-inf')
+        maxPathSumHelper(root)
+        return max_sum
+```
+
+You can then use this `Solution` class to find the maximum path sum of any non-empty path in the binary tree.

g0101_0200/s0128_longest_consecutive_sequence/readme.md

@@ -0,0 +1,62 @@
+128\. Longest Consecutive Sequence
+
+Medium
+
+Given an unsorted array of integers `nums`, return _the length of the longest consecutive elements sequence._
+
+You must write an algorithm that runs in `O(n)` time.
+
+**Example 1:**
+
+**Input:** nums = [100,4,200,1,3,2]
+
+**Output:** 4
+
+**Explanation:** The longest consecutive elements sequence is `[1, 2, 3, 4]`. Therefore its length is 4. 
+
+**Example 2:**
+
+**Input:** nums = [0,3,7,2,5,8,4,6,0,1]
+
+**Output:** 9 
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+
+To solve this task efficiently in O(n) time, we can use a HashSet to store all the elements of the array. Then, we can iterate through the array and for each element, check if the previous consecutive element (element - 1) exists in the set. If it does not exist, it means that the current element is the start of a new consecutive sequence. We can then keep track of the length of the consecutive sequence starting from the current element by continuously incrementing the current element until it no longer exists in the set. At each step, we update the maximum length of consecutive elements encountered so far. Here are the steps:
+
+1. Define the `Solution` class.
+2. Define the `longestConsecutive` method which takes `nums` as input.
+3. Create a set `num_set` to store all elements of the array.
+4. Initialize a variable `max_length` to store the maximum length of consecutive sequence encountered so far.
+5. Iterate through the elements of the array.
+6. For each element `num`, check if `num - 1` exists in `num_set`. If it does not exist, it means that `num` is the start of a new consecutive sequence.
+7. Increment `current_length` by 1 and continuously increment `num` until it no longer exists in `num_set`.
+8. Update `max_length` with the maximum of `max_length` and `current_length`.
+9. After iterating through all elements, return `max_length`.
+
+Here's the Python code implementing these steps:
+
+```python
+class Solution:
+    def longestConsecutive(self, nums):
+        num_set = set(nums)
+        max_length = 0
+        
+        for num in nums:
+            if num - 1 not in num_set:
+                current_num = num
+                current_length = 1
+                
+                while current_num + 1 in num_set:
+                    current_num += 1
+                    current_length += 1
+                
+                max_length = max(max_length, current_length)
+        
+        return max_length
+```
+
+You can then use this `Solution` class to find the length of the longest consecutive elements sequence in the given unsorted array.