Added tasks 226-238

Author: javadev

src/main/ts/g0201_0300/s0226_invert_binary_tree/readme.md

@@ -0,0 +1,32 @@
+226\. Invert Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, invert the tree, and return _its root_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg)
+
+**Input:** root = [4,2,7,1,3,6,9]
+
+**Output:** [4,7,2,9,6,3,1] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg)
+
+**Input:** root = [2,1,3]
+
+**Output:** [2,3,1] 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`

src/main/ts/g0201_0300/s0226_invert_binary_tree/solution.ts

@@ -0,0 +1,15 @@
+// #Easy #Top_100_Liked_Questions #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree
+// #Data_Structure_I_Day_12_Tree #Level_2_Day_6_Tree #Udemy_Tree_Stack_Queue
+// #Big_O_Time_O(n)_Space_O(n) #2023_10_09_Time_52_ms_(81.65%)_Space_44.2_MB_(79.49%)
+
+function invertTree(root: TreeNode | null): TreeNode | null {
+    if (root === null) {
+        return null
+    }
+    const temp = root.left
+    root.left = invertTree(root.right)
+    root.right = invertTree(temp)
+    return root
+}
+
+export { invertTree }

src/main/ts/g0201_0300/s0230_kth_smallest_element_in_a_bst/readme.md

@@ -0,0 +1,29 @@
+230\. Kth Smallest Element in a BST
+
+Medium
+
+Given the `root` of a binary search tree, and an integer `k`, return _the_ <code>k<sup>th</sup></code> _smallest value (**1-indexed**) of all the values of the nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg)
+
+**Input:** root = [3,1,4,null,2], k = 1
+
+**Output:** 1 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg)
+
+**Input:** root = [5,3,6,2,4,null,null,1], k = 3
+
+**Output:** 3 
+
+**Constraints:**
+
+*   The number of nodes in the tree is `n`.
+*   <code>1 <= k <= n <= 10<sup>4</sup></code>
+*   <code>0 <= Node.val <= 10<sup>4</sup></code>
+
+**Follow up:** If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?

src/main/ts/g0201_0300/s0230_kth_smallest_element_in_a_bst/solution.ts

@@ -0,0 +1,37 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Depth_First_Search #Tree #Binary_Tree
+// #Binary_Search_Tree #Data_Structure_II_Day_17_Tree #Level_2_Day_9_Binary_Search_Tree
+// #Big_O_Time_O(n)_Space_O(n) #2023_10_09_Time_54_ms_(97.22%)_Space_47.7_MB_(99.80%)
+
+/*
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+function kthSmallest(root: TreeNode | null, k: number): number {
+    let cur = root
+    while (cur !== null) {
+        if (cur.left !== null) {
+            const left = cur.left
+            cur.left = null
+            let rightmost = left
+            while (rightmost.right !== null) rightmost = rightmost.right
+            rightmost.right = cur
+            cur = left
+        } else if (--k !== 0) {
+            cur = cur.right
+        } else {
+            break
+        }
+    }
+    return cur.val
+}
+
+export { kthSmallest }

src/main/ts/g0201_0300/s0234_palindrome_linked_list/readme.md

@@ -0,0 +1,28 @@
+234\. Palindrome Linked List
+
+Easy
+
+Given the `head` of a singly linked list, return `true` if it is a palindrome.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg)
+
+**Input:** head = [1,2,2,1]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg)
+
+**Input:** head = [1,2]
+
+**Output:** false 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.
+*   `0 <= Node.val <= 9`
+
+**Follow up:** Could you do it in `O(n)` time and `O(1)` space?

src/main/ts/g0201_0300/s0234_palindrome_linked_list/solution.ts

@@ -0,0 +1,56 @@
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Two_Pointers #Stack #Linked_List
+// #Recursion #Level_2_Day_3_Linked_List #Udemy_Linked_List #Big_O_Time_O(n)_Space_O(1)
+// #2023_10_09_Time_96_ms_(95.67%)_Space_72.8_MB_(87.01%)
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+function isPalindrome(head: ListNode | null): boolean {
+    if (head === null || head.next === null) {
+        // Empty list or single element is considered a palindrome.
+        return true
+    }
+    let len = 0
+    let right = head
+    // Calculate the length of the list.
+    while (right !== null) {
+        right = right.next
+        len++
+    }
+    // Find the middle of the list.
+    let middle = Math.floor(len / 2)
+    // Reset the right pointer to the head.
+    right = head
+    // Move the right pointer to the middle of the list.
+    for (let i = 0; i < middle; i++) {
+        right = right.next
+    }
+    // Reverse the right half of the list.
+    let prev = null
+    while (right !== null) {
+        const next = right.next
+        right.next = prev
+        prev = right
+        right = next
+    }
+    // Compare the left and right halves.
+    for (let i = 0; i < middle; i++) {
+        if (prev !== null && head.val === prev.val) {
+            head = head.next
+            prev = prev.next
+        } else {
+            return false
+        }
+    }
+    return true
+}
+
+export { isPalindrome }

src/main/ts/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/readme.md

@@ -0,0 +1,41 @@
+236\. Lowest Common Ancestor of a Binary Tree
+
+Medium
+
+Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
+
+According to the [definition of LCA on Wikipedia](https://en.wikipedia.org/wiki/Lowest_common_ancestor): “The lowest common ancestor is defined between two nodes `p` and `q` as the lowest node in `T` that has both `p` and `q` as descendants (where we allow **a node to be a descendant of itself**).”
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png)
+
+**Input:** root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+
+**Output:** 3
+
+**Explanation:** The LCA of nodes 5 and 1 is 3. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png)
+
+**Input:** root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+
+**Output:** 5
+
+**Explanation:** The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition. 
+
+**Example 3:**
+
+**Input:** root = [1,2], p = 1, q = 2
+
+**Output:** 1 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.
+*   <code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code>
+*   All `Node.val` are **unique**.
+*   `p != q`
+*   `p` and `q` will exist in the tree.

src/main/ts/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/solution.ts

@@ -0,0 +1,36 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Depth_First_Search #Tree #Binary_Tree
+// #Data_Structure_II_Day_18_Tree #Udemy_Tree_Stack_Queue #Big_O_Time_O(n)_Space_O(n)
+// #2023_10_09_Time_59_ms_(96.11%)_Space_52.8_MB_(24.18%)
+
+/*
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
+    if (root === null) {
+        return null
+    }
+    if (root.val === p.val || root.val === q.val) {
+        return root
+    }
+    const left = lowestCommonAncestor(root.left, p, q)
+    const right = lowestCommonAncestor(root.right, p, q)
+    if (left !== null && right !== null) {
+        return root
+    }
+    if (left !== null) {
+        return left
+    }
+    return right
+}
+
+export { lowestCommonAncestor }

src/main/ts/g0201_0300/s0238_product_of_array_except_self/readme.md

@@ -0,0 +1,29 @@
+238\. Product of Array Except Self
+
+Medium
+
+Given an integer array `nums`, return _an array_ `answer` _such that_ `answer[i]` _is equal to the product of all the elements of_ `nums` _except_ `nums[i]`.
+
+The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+You must write an algorithm that runs in `O(n)` time and without using the division operation.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** [24,12,8,6] 
+
+**Example 2:**
+
+**Input:** nums = [-1,1,0,-3,3]
+
+**Output:** [0,0,9,0,0] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   `-30 <= nums[i] <= 30`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+**Follow up:** Can you solve the problem in `O(1) `extra space complexity? (The output array **does not** count as extra space for space complexity analysis.)

src/main/ts/g0201_0300/s0238_product_of_array_except_self/solution.ts

@@ -0,0 +1,23 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Prefix_Sum
+// #Data_Structure_II_Day_5_Array #Udemy_Arrays #Big_O_Time_O(n^2)_Space_O(n)
+// #2023_10_09_Time_89_ms_(64.48%)_Space_55.4_MB_(36.71%)
+
+function productExceptSelf(nums: number[]): number[] {
+    const n = nums.length
+    const ans: number[] = new Array(n)
+    let product = 1
+    // Calculate the product of all elements to the left of each element
+    for (let i = 0; i < n; i++) {
+        ans[i] = product
+        product *= nums[i]
+    }
+    product = 1
+    // Calculate the product of all elements to the right of each element
+    for (let i = n - 1; i >= 0; i--) {
+        ans[i] *= product
+        product *= nums[i]
+    }
+    return ans
+}
+
+export { productExceptSelf }