Added tasks 99, 100, 103, 106.

Author: ThanhNIT

README.md

@@ -536,6 +536,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0104 |[Maximum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 236 | 83.39
 
 #### Day 11 Containers and Libraries
 
@@ -973,6 +974,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0100 |[Same Tree](src/main/kotlin/g0001_0100/s0100_same_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 267 | 24.51
 | 0101 |[Symmetric Tree](src/main/kotlin/g0101_0200/s0101_symmetric_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 290 | 26.98
 | 0199 |[Binary Tree Right Side View](src/main/kotlin/g0101_0200/s0199_binary_tree_right_side_view/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 194 | 92.89
 
@@ -1106,8 +1108,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 |-|-|-|-|-|-
 | 0094 |[Largest Rectangle in Histogram](src/main/kotlin/g0001_0100/s0094_binary_tree_inorder_traversal/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Stack | 269 | 38.80
 | 0102 |[Binary Tree Level Order Traversal](src/main/kotlin/g0101_0200/s0102_binary_tree_level_order_traversal/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree | 355 | 29.37
+| 0103 |[Binary Tree Zigzag Level Order Traversal](src/main/kotlin/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/Solution.kt)| Medium | Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree | 316 | 34.25
 | 0543 |[Diameter of Binary Tree](src/main/kotlin/g0501_0600/s0543_diameter_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree | 307 | 43.93
+| 0100 |[Same Tree](src/main/kotlin/g0001_0100/s0100_same_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 267 | 24.51
 | 0226 |[Invert Binary Tree](src/main/kotlin/g0201_0300/s0226_invert_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 233 | 54.90
+| 0104 |[Maximum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 236 | 83.39
 | 0124 |[Binary Tree Maximum Path Sum](src/main/kotlin/g0101_0200/s0124_binary_tree_maximum_path_sum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Depth_First_Search, Tree, Binary_Tree | 331 | 74.42
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 330 | 41.38
 | 0236 |[Lowest Common Ancestor of a Binary Tree](src/main/kotlin/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree | 386 | 45.21
@@ -1231,6 +1236,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0102 |[Binary Tree Level Order Traversal](src/main/kotlin/g0101_0200/s0102_binary_tree_level_order_traversal/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree | 355 | 29.37
+| 0104 |[Maximum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 236 | 83.39
 | 0101 |[Symmetric Tree](src/main/kotlin/g0101_0200/s0101_symmetric_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 290 | 26.98
 
 #### Day 12 Tree
@@ -1348,6 +1354,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0105 |[Construct Binary Tree from Preorder and Inorder Traversal](src/main/kotlin/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Tree, Binary_Tree, Divide_and_Conquer | 370 | 58.31
+| 0103 |[Binary Tree Zigzag Level Order Traversal](src/main/kotlin/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/Solution.kt)| Medium | Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree | 316 | 34.25
 
 #### Day 16 Tree
 
@@ -1527,9 +1534,14 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0124 |[Binary Tree Maximum Path Sum](src/main/kotlin/g0101_0200/s0124_binary_tree_maximum_path_sum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Depth_First_Search, Tree, Binary_Tree, Udemy_Tree_Stack_Queue | 331 | 74.42
 | 0121 |[Best Time to Buy and Sell Stock](src/main/kotlin/g0101_0200/s0121_best_time_to_buy_and_sell_stock/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Data_Structure_I_Day_3_Array, Dynamic_Programming_I_Day_7, Level_1_Day_5_Greedy, Udemy_Arrays | 609 | 94.06
 | 0114 |[Flatten Binary Tree to Linked List](src/main/kotlin/g0101_0200/s0114_flatten_binary_tree_to_linked_list/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Linked_List, Udemy_Linked_List | 191 | 93.10
+| 0106 |[Construct Binary Tree from Inorder and Postorder Traversal](src/main/kotlin/g0101_0200/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.kt)| Medium | Array, Hash_Table, Tree, Binary_Tree, Divide_and_Conquer | 358 | 61.29
 | 0105 |[Construct Binary Tree from Preorder and Inorder Traversal](src/main/kotlin/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Tree, Binary_Tree, Divide_and_Conquer, Data_Structure_II_Day_15_Tree | 370 | 58.31
+| 0104 |[Maximum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_11_Tree, Programming_Skills_I_Day_10_Linked_List_and_Tree, Udemy_Tree_Stack_Queue | 236 | 83.39
+| 0103 |[Binary Tree Zigzag Level Order Traversal](src/main/kotlin/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/Solution.kt)| Medium | Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_II_Day_15_Tree, Udemy_Tree_Stack_Queue | 316 | 34.25
 | 0102 |[Binary Tree Level Order Traversal](src/main/kotlin/g0101_0200/s0102_binary_tree_level_order_traversal/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_11_Tree, Level_1_Day_6_Tree, Udemy_Tree_Stack_Queue | 355 | 29.37
 | 0101 |[Symmetric Tree](src/main/kotlin/g0101_0200/s0101_symmetric_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_11_Tree, Level_2_Day_15_Tree | 290 | 26.98
+| 0100 |[Same Tree](src/main/kotlin/g0001_0100/s0100_same_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Level_2_Day_15_Tree, Udemy_Tree_Stack_Queue | 267 | 24.51
+| 0099 |[Recover Binary Search Tree](src/main/kotlin/g0001_0100/s0099_recover_binary_search_tree/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 492 | 39.39
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| 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 | 330 | 41.38
 | 0097 |[Interleaving String](src/main/kotlin/g0001_0100/s0097_interleaving_string/Solution.kt)| Medium | String, Dynamic_Programming | 240 | 57.50
 | 0096 |[Unique Binary Search Trees](src/main/kotlin/g0001_0100/s0096_unique_binary_search_trees/Solution.kt)| Medium | Top_100_Liked_Questions, Dynamic_Programming, Math, Tree, Binary_Tree, Binary_Search_Tree, Dynamic_Programming_I_Day_11 | 237 | 26.76

src/main/kotlin/g0001_0100/s0099_recover_binary_search_tree/Solution.kt

@@ -0,0 +1,44 @@
+package g0001_0100.s0099_recover_binary_search_tree
+
+// #Medium #Depth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+// #2022_09_27_Time_492_ms_(39.39%)_Space_50.6_MB_(21.21%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var prev: TreeNode? = null
+    private var first: TreeNode? = null
+    private var second: TreeNode? = null
+
+    fun recoverTree(root: TreeNode?) {
+        evalSwappedNodes(root)
+        val temp: Int = first!!.`val`
+        first!!.`val` = second!!.`val`
+        second!!.`val` = temp
+    }
+
+    private fun evalSwappedNodes(curr: TreeNode?) {
+        if (curr == null) {
+            return
+        }
+        evalSwappedNodes(curr.left)
+        if (prev != null && prev!!.`val` > curr.`val`) {
+            if (first == null) {
+                first = prev
+            }
+            second = curr
+        }
+        prev = curr
+        evalSwappedNodes(curr.right)
+    }
+}

src/main/kotlin/g0001_0100/s0099_recover_binary_search_tree/readme.md

@@ -0,0 +1,32 @@
+99\. Recover Binary Search Tree
+
+Medium
+
+You are given the `root` of a binary search tree (BST), where the values of **exactly** two nodes of the tree were swapped by mistake. _Recover the tree without changing its structure_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/28/recover1.jpg)
+
+**Input:** root = [1,3,null,null,2]
+
+**Output:** [3,1,null,null,2]
+
+**Explanation:** 3 cannot be a left child of 1 because 3 > 1. Swapping 1 and 3 makes the BST valid.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/28/recover2.jpg)
+
+**Input:** root = [3,1,4,null,null,2]
+
+**Output:** [2,1,4,null,null,3]
+
+**Explanation:** 2 cannot be in the right subtree of 3 because 2 < 3. Swapping 2 and 3 makes the BST valid.
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[2, 1000]`.
+*   <code>-2<sup>31</sup> <= Node.val <= 2<sup>31</sup> - 1</code>
+
+**Follow up:** A solution using `O(n)` space is pretty straight-forward. Could you devise a constant `O(1)` space solution?

src/main/kotlin/g0001_0100/s0100_same_tree/Solution.kt

@@ -0,0 +1,37 @@
+package g0001_0100.s0100_same_tree
+
+// #Easy #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree #Level_2_Day_15_Tree
+// #Udemy_Tree_Stack_Queue #2022_09_27_Time_267_ms_(24.51%)_Space_34.1_MB_(43.10%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private fun trav(n: TreeNode?, m: TreeNode?): Boolean {
+        return if (n != null && m != null) {
+            if (n.`val` !== m.`val`) {
+                false
+            } else trav(n.left, m.left) && trav(n.right, m.right)
+        } else {
+            n == null && m == null
+        }
+    }
+
+    fun isSameTree(p: TreeNode?, q: TreeNode?): Boolean {
+        if (p == null && q == null) {
+            return true
+        } else if (p == null || q == null) {
+            return false
+        }
+        return trav(p, q)
+    }
+}

src/main/kotlin/g0001_0100/s0100_same_tree/readme.md

@@ -0,0 +1,36 @@
+100\. Same Tree
+
+Easy
+
+Given the roots of two binary trees `p` and `q`, write a function to check if they are the same or not.
+
+Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg)
+
+**Input:** p = [1,2,3], q = [1,2,3]
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg)
+
+**Input:** p = [1,2], q = [1,null,2]
+
+**Output:** false
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg)
+
+**Input:** p = [1,2,1], q = [1,1,2]
+
+**Output:** false
+
+**Constraints:**
+
+*   The number of nodes in both trees is in the range `[0, 100]`.
+*   <code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code>

src/main/kotlin/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/Solution.kt

@@ -0,0 +1,57 @@
+package g0101_0200.s0103_binary_tree_zigzag_level_order_traversal
+
+// #Medium #Top_Interview_Questions #Breadth_First_Search #Tree #Binary_Tree
+// #Data_Structure_II_Day_15_Tree #Udemy_Tree_Stack_Queue
+// #2022_09_27_Time_316_ms_(34.25%)_Space_35.3_MB_(95.21%)
+
+import com_github_leetcode.TreeNode
+import java.util.LinkedList
+import java.util.Queue
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun zigzagLevelOrder(root: TreeNode?): List<List<Int>> {
+        val result: MutableList<List<Int>> = ArrayList()
+        if (root == null) {
+            return result
+        }
+        val q: Queue<TreeNode> = LinkedList()
+        q.add(root)
+        q.add(null)
+        var zig = true
+        var level = LinkedList<Int>()
+        while (!q.isEmpty()) {
+            var node: TreeNode? = q.remove()
+            while (!q.isEmpty() && node != null) {
+                if (zig) {
+                    level.add(node.`val`)
+                } else {
+                    level.addFirst(node.`val`)
+                }
+                if (node.left != null) {
+                    q.add(node.left)
+                }
+                if (node.right != null) {
+                    q.add(node.right)
+                }
+                node = q.remove()
+            }
+            result.add(level)
+            zig = !zig
+            level = LinkedList()
+            if (!q.isEmpty()) {
+                q.add(null)
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/readme.md

@@ -0,0 +1,30 @@
+103\. Binary Tree Zigzag Level Order Traversal
+
+Medium
+
+Given the `root` of a binary tree, return _the zigzag level order traversal of its nodes' values_. (i.e., from left to right, then right to left for the next level and alternate between).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** [[3],[20,9],[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]`.
+*   `-100 <= Node.val <= 100`

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

@@ -0,0 +1,26 @@
+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
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   `-100 <= Node.val <= 100`

src/main/kotlin/g0101_0200/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/Solution.kt

@@ -0,0 +1,35 @@
+package g0101_0200.s0106_construct_binary_tree_from_inorder_and_postorder_traversal
+
+// #Medium #Array #Hash_Table #Tree #Binary_Tree #Divide_and_Conquer
+// #2022_09_27_Time_358_ms_(61.29%)_Space_37.1_MB_(96.77%)
+
+import com_github_leetcode.TreeNode
+
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun buildTree(inorder: IntArray, postorder: IntArray): TreeNode? {
+        val inIndex = intArrayOf(inorder.size - 1)
+        val postIndex = intArrayOf(postorder.size - 1)
+        return helper(inorder, postorder, inIndex, postIndex, Int.MAX_VALUE)
+    }
+
+    private fun helper(`in`: IntArray, post: IntArray, index: IntArray, pIndex: IntArray, target: Int): TreeNode? {
+        if (index[0] < 0 || `in`[index[0]] == target) {
+            return null
+        }
+        val root = TreeNode(post[pIndex[0]--])
+        root.right = helper(`in`, post, index, pIndex, root.`val`)
+        index[0]--
+        root.left = helper(`in`, post, index, pIndex, target)
+        return root
+    }
+}

src/main/kotlin/g0101_0200/s0106_construct_binary_tree_from_inorder_and_postorder_traversal/readme.md

@@ -0,0 +1,29 @@
+106\. Construct Binary Tree from Inorder and Postorder Traversal
+
+Medium
+
+Given two integer arrays `inorder` and `postorder` where `inorder` is the inorder traversal of a binary tree and `postorder` is the postorder traversal of the same tree, construct and return _the binary tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg)
+
+**Input:** inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
+
+**Output:** [3,9,20,null,null,15,7]
+
+**Example 2:**
+
+**Input:** inorder = [-1], postorder = [-1]
+
+**Output:** [-1]
+
+**Constraints:**
+
+*   `1 <= inorder.length <= 3000`
+*   `postorder.length == inorder.length`
+*   `-3000 <= inorder[i], postorder[i] <= 3000`
+*   `inorder` and `postorder` consist of **unique** values.
+*   Each value of `postorder` also appears in `inorder`.
+*   `inorder` is **guaranteed** to be the inorder traversal of the tree.
+*   `postorder` is **guaranteed** to be the postorder traversal of the tree.