Added tasks 79-98

Author: ThanhNIT

README.md

@@ -167,6 +167,7 @@ JavaScript-based LeetCode algorithm problem solutions, regularly updated.
 |-|-|-|-|-|-
 | 0017 |[Letter Combinations of a Phone Number](src/main/js/g0001_0100/s0017_letter_combinations_of_a_phone_number/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Backtracking, Big_O_Time_O(4^n)_Space_O(n) | 0 | 100.00
 | 0022 |[Generate Parentheses](src/main/js/g0001_0100/s0022_generate_parentheses/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Dynamic_Programming, Backtracking, Big_O_Time_O(2^n)_Space_O(n) | 0 | 100.00
+| 0079 |[Word Search](src/main/js/g0001_0100/s0079_word_search/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Matrix, Backtracking, Big_O_Time_O(4^(m\*n))_Space_O(m\*n) | 292 | 83.26
 
 #### Day 12 Dynamic Programming
 
@@ -452,6 +453,7 @@ JavaScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0096 |[Unique Binary Search Trees](src/main/js/g0001_0100/s0096_unique_binary_search_trees/solution.js)| Medium | Dynamic_Programming, Math, Tree, Binary_Tree, Binary_Search_Tree, Big_O_Time_O(n)_Space_O(1) | 0 | 100.00
 
 #### Day 12
 
@@ -840,6 +842,7 @@ JavaScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0098 |[Validate Binary Search Tree](src/main/js/g0001_0100/s0098_validate_binary_search_tree/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Big_O_Time_O(N)_Space_O(log(N)) | 0 | 100.00
 
 #### Day 9 Graph/BFS/DFS
 
@@ -1061,6 +1064,8 @@ JavaScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0094 |[Binary Tree Inorder Traversal](src/main/js/g0001_0100/s0094_binary_tree_inorder_traversal/solution.js)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Big_O_Time_O(n)_Space_O(n) | 0 | 100.00
+| 0098 |[Validate Binary Search Tree](src/main/js/g0001_0100/s0098_validate_binary_search_tree/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Big_O_Time_O(N)_Space_O(log(N)) | 0 | 100.00
 
 #### Udemy Trie and Heap
 
@@ -1157,6 +1162,7 @@ JavaScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0094 |[Binary Tree Inorder Traversal](src/main/js/g0001_0100/s0094_binary_tree_inorder_traversal/solution.js)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Big_O_Time_O(n)_Space_O(n) | 0 | 100.00
 
 #### Day 11 Tree
 
@@ -1177,6 +1183,7 @@ JavaScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0098 |[Validate Binary Search Tree](src/main/js/g0001_0100/s0098_validate_binary_search_tree/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Big_O_Time_O(N)_Space_O(log(N)) | 0 | 100.00
 
 ### Data Structure II
 
@@ -1298,6 +1305,11 @@ JavaScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 0098 |[Validate Binary Search Tree](src/main/js/g0001_0100/s0098_validate_binary_search_tree/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_14_Tree, Level_1_Day_8_Binary_Search_Tree, Udemy_Tree_Stack_Queue, Big_O_Time_O(N)_Space_O(log(N)) | 0 | 100.00
+| 0096 |[Unique Binary Search Trees](src/main/js/g0001_0100/s0096_unique_binary_search_trees/solution.js)| Medium | Dynamic_Programming, Math, Tree, Binary_Tree, Binary_Search_Tree, Dynamic_Programming_I_Day_11, Big_O_Time_O(n)_Space_O(1) | 0 | 100.00
+| 0094 |[Binary Tree Inorder Traversal](src/main/js/g0001_0100/s0094_binary_tree_inorder_traversal/solution.js)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Data_Structure_I_Day_10_Tree, Udemy_Tree_Stack_Queue, Big_O_Time_O(n)_Space_O(n) | 0 | 100.00
+| 0084 |[Largest Rectangle in Histogram](src/main/js/g0001_0100/s0084_largest_rectangle_in_histogram/solution.js)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Stack, Monotonic_Stack, Big_O_Time_O(n_log_n)_Space_O(log_n) | 11 | 96.58
+| 0079 |[Word Search](src/main/js/g0001_0100/s0079_word_search/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Matrix, Backtracking, Algorithm_II_Day_11_Recursion_Backtracking, Big_O_Time_O(4^(m\*n))_Space_O(m\*n) | 292 | 83.26
 | 0078 |[Subsets](src/main/js/g0001_0100/s0078_subsets/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, Backtracking, Algorithm_II_Day_9_Recursion_Backtracking, Udemy_Backtracking/Recursion, Big_O_Time_O(2^n)_Space_O(n\*2^n) | 0 | 100.00
 | 0076 |[Minimum Window Substring](src/main/js/g0001_0100/s0076_minimum_window_substring/solution.js)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Sliding_Window, Level_2_Day_14_Sliding_Window/Two_Pointer, Big_O_Time_O(s.length())_Space_O(1) | 4 | 99.86
 | 0075 |[Sort Colors](src/main/js/g0001_0100/s0075_sort_colors/solution.js)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Data_Structure_II_Day_2_Array, Udemy_Arrays, Big_O_Time_O(n)_Space_O(1) | 0 | 100.00

src/main/js/com_github_leetcode/treenode.js

@@ -0,0 +1,33 @@
+class TreeNode {
+    constructor(val = 0, left = null, right = null) {
+        this.val = val
+        this.left = left
+        this.right = right
+    }
+};
+
+function createTreeNode(treeValues) {
+    if (treeValues.length === 0) return null
+
+    const root = new TreeNode(treeValues[0])
+    const queue = [root]
+    let i = 1
+
+    while (i < treeValues.length) {
+        const curr = queue.shift()
+        if (treeValues[i] !== null) {
+            curr.left = new TreeNode(treeValues[i])
+            queue.push(curr.left)
+        }
+        i++
+        if (i < treeValues.length && treeValues[i] !== null) {
+            curr.right = new TreeNode(treeValues[i])
+            queue.push(curr.right)
+        }
+        i++
+    }
+
+    return root
+};
+
+export { TreeNode, createTreeNode }

src/main/js/g0001_0100/s0079_word_search/readme.md

@@ -0,0 +1,41 @@
+79\. Word Search
+
+Medium
+
+Given an `m x n` grid of characters `board` and a string `word`, return `true` _if_ `word` _exists in the grid_.
+
+The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/word2.jpg)
+
+**Input:** board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/word-1.jpg)
+
+**Input:** board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
+
+**Output:** true
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2020/10/15/word3.jpg)
+
+**Input:** board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
+
+**Output:** false
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n = board[i].length`
+*   `1 <= m, n <= 6`
+*   `1 <= word.length <= 15`
+*   `board` and `word` consists of only lowercase and uppercase English letters.
+
+**Follow up:** Could you use search pruning to make your solution faster with a larger `board`?

src/main/js/g0001_0100/s0079_word_search/solution.js

@@ -0,0 +1,43 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Matrix #Backtracking
+// #Algorithm_II_Day_11_Recursion_Backtracking #Big_O_Time_O(4^(m*n))_Space_O(m*n)
+// #2024_12_12_Time_292_ms_(83.26%)_Space_49.6_MB_(62.55%)
+
+/**
+ * @param {character[][]} board
+ * @param {string} word
+ * @return {boolean}
+ */
+var exist = function (board, word) {
+    let visited = Array.from({ length: board.length }, () => Array(board[0].length).fill(0)),
+        m = board.length, n = board[0].length, isMatch = false
+    const dfs = (i, j, match) => {
+        visited[i][j] = 1
+        if (match == word.length) {
+            isMatch = true
+            return
+        }
+        let x = [1, -1, 0, 0], y = [0, 0, 1, -1]
+        for (let k = 0; k < 4; k++) {
+            let xx = x[k] + i, yy = y[k] + j
+            if (xx >= 0 && yy >= 0 && xx < m && yy < n && visited[xx][yy] != 1 && board[xx][yy] == word[match]) {
+                dfs(xx, yy, match + 1)
+                visited[xx][yy] = 0
+            }
+        }
+    }
+    for (let i = 0; i < board.length; i++) {
+        for (let j = 0; j < board[0].length; j++) {
+            if (board[i][j] == word[0]) {
+                dfs(i, j, 1)
+                if (isMatch) {
+                    return true
+                }
+                visited = Array.from({ length: board.length }, () => Array(board[0].length).fill(0))
+
+            }
+        }
+    }
+    return isMatch
+};
+
+export { exist }

src/main/js/g0001_0100/s0084_largest_rectangle_in_histogram/readme.md

@@ -0,0 +1,30 @@
+84\. Largest Rectangle in Histogram
+
+Hard
+
+Given an array of integers `heights` representing the histogram's bar height where the width of each bar is `1`, return _the area of the largest rectangle in the histogram_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg)
+
+**Input:** heights = [2,1,5,6,2,3]
+
+**Output:** 10
+
+**Explanation:** The above is a histogram where width of each bar is 1. 
+
+The largest rectangle is shown in the red area, which has an area = 10 units.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg)
+
+**Input:** heights = [2,4]
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= heights.length <= 10<sup>5</sup></code>
+*   <code>0 <= heights[i] <= 10<sup>4</sup></code>

src/main/js/g0001_0100/s0084_largest_rectangle_in_histogram/solution.js

@@ -0,0 +1,32 @@
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Stack #Monotonic_Stack
+// #Big_O_Time_O(n_log_n)_Space_O(log_n) #2024_12_12_Time_11_ms_(96.58%)_Space_61.2_MB_(84.95%)
+
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+var largestRectangleArea = function(heights) {
+    let stack = []
+    let maxArea = 0
+    let index = 0
+
+    while (index < heights.length) {
+        if (stack.length === 0 || heights[stack[stack.length - 1]] <= heights[index]) {
+            stack.push(index++)
+        } else {
+            let top = stack.pop()
+            let area = heights[top] * (stack.length === 0 ? index : index - stack[stack.length - 1] - 1)
+            maxArea = Math.max(maxArea, area)
+        }
+    }
+
+    while (stack.length > 0) {
+        let top = stack.pop()
+        let area = heights[top] * (stack.length === 0 ? index : index - stack[stack.length - 1] - 1)
+        maxArea = Math.max(maxArea, area)
+    }
+
+    return maxArea
+};
+
+export { largestRectangleArea }

src/main/js/g0001_0100/s0094_binary_tree_inorder_traversal/readme.md

@@ -0,0 +1,48 @@
+94\. Binary Tree Inorder Traversal
+
+Easy
+
+Given the `root` of a binary tree, return _the inorder traversal of its nodes' values_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg)
+
+**Input:** root = [1,null,2,3]
+
+**Output:** [1,3,2] 
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** root = [1]
+
+**Output:** [1] 
+
+**Example 4:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg)
+
+**Input:** root = [1,2]
+
+**Output:** [2,1] 
+
+**Example 5:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg)
+
+**Input:** root = [1,null,2]
+
+**Output:** [1,2] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`
+
+**Follow up:** Recursive solution is trivial, could you do it iteratively?

src/main/js/g0001_0100/s0094_binary_tree_inorder_traversal/solution.js

@@ -0,0 +1,39 @@
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Depth_First_Search #Tree #Binary_Tree
+// #Stack #Data_Structure_I_Day_10_Tree #Udemy_Tree_Stack_Queue #Big_O_Time_O(n)_Space_O(n)
+// #2024_12_12_Time_0_ms_(100.00%)_Space_49.4_MB_(12.74%)
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var inorderTraversal = function(root) {
+    if (root === null) {
+        return []
+    }
+    const answer = []
+    traverseInOrder(root, answer)
+    return answer
+};
+
+var traverseInOrder = function(root, answer) {
+    if (root === null) {
+        return
+    }
+    if (root.left !== null) {
+        traverseInOrder(root.left, answer)
+    }
+    answer.push(root.val)
+    if (root.right !== null) {
+        traverseInOrder(root.right, answer)
+    }
+};
+
+export { inorderTraversal }

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

@@ -0,0 +1,23 @@
+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`

src/main/js/g0001_0100/s0096_unique_binary_search_trees/solution.js

@@ -0,0 +1,21 @@
+// #Medium #Dynamic_Programming #Math #Tree #Binary_Tree #Binary_Search_Tree
+// #Dynamic_Programming_I_Day_11 #Big_O_Time_O(n)_Space_O(1)
+// #2024_12_12_Time_0_ms_(100.00%)_Space_48.8_MB_(65.65%)
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var numTrees = function (n) {
+    let result = 1
+
+    for (let i = 0; i < n; i++) {
+        result *= 2 * n - i
+        result /= i + 1
+    }
+
+    result /= n + 1
+    return Math.floor(result)
+};
+
+export { numTrees }