Add solutions to some new problems

69. Sqrt(x)
437. Path Sum III
662. Maximum Width of Binary Tree
540. Single Element in a Sorted Array
463. Island Perimeter
167. Two Sum II - Input Array Is Sorted
57. Insert Interval
1457. Pseudo-Palindromic Paths in a Binary Tree
1325. Delete Leaves With a Given Value

Author: enginebai

README.md

@@ -20,7 +20,7 @@ This project are curated resources and notes of basic/fundamental/popular data s
 - [Greedy](./topics/greedy.md)
 - [Backtracking](./topics/backtracking.md)
 - [Hash Table](./topics/hash-table.md)
-- [Searching](./topics/searching.md)
+- [Binary Search](./topics/binary-search.md)
 - [Sorting](./topics/sorting.md)
 - (TODO) [Other](./topics/other.md)
 - 👉 [Problems & Solutions](./topics/problems-solutions.md)

leetcode/100.same-tree.md

@@ -8,6 +8,9 @@ fun isSameTree(p: TreeNode?, q: TreeNode?): Boolean {
 }
 ```
 
+* **Time Complexity**: `O(min(|P|, |Q|))`, where `|P|` and `|Q|` are the number of tree nodes of `p` and `q`.
+* **Space Complexity**: `O(min(|P|, |Q|))`
+
 ### Traversal
 ```kotlin
 class Solution {

leetcode/102.binary-tree-level-order-traversal.md

@@ -1,36 +1,6 @@
 ## [102. Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)
 
-```kotlin
-class Solution {
-
-    data class MyNode(
-        val node: TreeNode,
-        val level: Int
-    )
-
-    private val results = mutableListOf<MutableList<Int>>()
-
-    fun levelOrder(root: TreeNode?): List<List<Int>> {
-        val queue = ArrayDeque<MyNode>()
-        if (root == null) return emptyList()
-        queue.addLast(MyNode(root, 0))
-        while (!queue.isEmpty()) {
-            val myNode = queue.removeFirst()
-            if (myNode.node.left != null) queue.addLast(MyNode(myNode.node.left, myNode.level + 1))
-            if (myNode.node.right != null) queue.addLast(MyNode(myNode.node.right, myNode.level + 1))
-
-            if (results.size < myNode.level + 1) {
-                results.add(mutableListOf<Int>())
-            }
-            results[myNode.level].add(myNode.node.`val`)
-        }
-        return results
-    }
-}
-```
-
-Solution without addition `level` variable:
-
+### Iterative
 ```kotlin
 fun levelOrder(root: TreeNode?): List<List<Int>> {
     if (root == null) return emptyList()
@@ -52,4 +22,31 @@ fun levelOrder(root: TreeNode?): List<List<Int>> {
     }
     return results
 }
-```
+```
+
+## Recursive
+```kotlin
+val results = mutableListOf<MutableList<Int>>()
+    
+fun levelOrder(root: TreeNode?): List<List<Int>> {
+    traversal(root, 0)
+    return results
+}
+
+private fun traversal(root: TreeNode?, level: Int) {
+    if (root == null) return
+    val nodes = results.getOrNull(level)
+    if (nodes == null) {
+        val list = mutableListOf<Int>()
+        list.add(root.`val`)
+        results.add(list)
+    } else {
+        results[level].add(root.`val`)
+    }
+    traversal(root.left, level + 1)
+    traversal(root.right, level + 1)
+}
+```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.

leetcode/1091.shortest-path-in-binary-matrix.md

@@ -13,20 +13,18 @@ private val directions = arrayOf(
         )
 
 fun shortestPathBinaryMatrix(grid: Array<IntArray>): Int {
-    val infinite = Int.MAX_VALUE / 2
     val n = grid.size
-    if (grid[0][0] == 1 || grid[n -1][n - 1] == 1) return -1
+    if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1) return -1
 
-    val distances = Array(n) { _ -> IntArray(n) { _ -> infinite }}
+    val distances = Array(n) { _ -> IntArray(n) { _ -> Int.MAX_VALUE }}
     val queue = ArrayDeque<Pair<Int, Int>>()
     queue.add(0 to 0)
-    visited.add(0 to 0)
     distances[0][0] = 1
     while (!queue.isEmpty()) {
         val node = queue.removeFirst()
         val x = node.first
         val y = node.second
-        if (x == n -1 && y == n - 1) return distances[x][y]
+        if (x == n - 1 && y == n - 1) return distances[x][y]
         directions.forEach { d ->
             val newX = x + d[0]
             val newY = y + d[1]
@@ -42,3 +40,6 @@ fun shortestPathBinaryMatrix(grid: Array<IntArray>): Int {
     return -1
 }
 ```
+
+* **Time Complexity**: `O(n^2)`.
+* **Space Complexity**: `O(n^2)`.

leetcode/110.balanced-binary-tree.md

@@ -21,11 +21,12 @@ private fun max(n1: Int, n2: Int) = if (n1 > n2) n1 else n2
 ```
 
 * **Time Complexity**: Calculate the height = `O(lg n)`, and we have to calculate every node `n`, the average case (every node has children) is `O(n lg n)`, but the worst case is `O(n^2)` when the tree is skewed because the height becomes `O(n)`.
+* **Space Complexity**: `O(n)`.
 
 > We can calculate the height and store it, then traversal to check. That would be `O(n)` time and space complexity.
 
 ### Bottom-Up Solution (Optimal)
-* We traverse all nodes in postorder, and determine if it's balanced of its child nodes, then check the current node.
+* We calculate the height (left and right) and check if it is balanced at the same function call, and if it's not balanced then return -1 to indicate unbalanced.
 * If it's not balanced from its child node, then it's not balanced as well for the current node.
 
 ![](../media/110.balanced-binary-tree.png)
@@ -46,6 +47,7 @@ private fun getHeight(root: TreeNode?): Int {
 }
 ```
 * **Time Complexity**: It becomes `O(n)` since we calculate the height only once for every node.
+* **Space Complexity**: `O(n)`.
 
 ### My Solution (Accepted)
 ```kotlin

leetcode/112.path-sum.md

@@ -8,4 +8,7 @@ fun hasPathSum(root: TreeNode?, targetSum: Int): Boolean {
         return hasPathSum(root.left, targetSum - root.`val`) || hasPathSum(root.right, targetSum - root.`val`)
     }
 }
-```
+```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.

leetcode/113.path-sum-ii.md

@@ -29,4 +29,8 @@ private fun dfs(root: TreeNode?, targetSum: Int, path: MutableList<Int>) {
         path.removeAt(path.size - 1)
     }
 }
-```
+```
+
+> Not fully understand.
+* **Time Complexity**: `O(n^2)`? https://leetcode.cn/problems/path-sum-ii/solution/lu-jing-zong-he-ii-by-leetcode-solution/, but why?
+* **Space Complexity**: `O(n)` for recursive call stack.

leetcode/116.populating-next-right-pointers-in-each-node.md

@@ -18,4 +18,10 @@ fun connect(root: Node?): Node? {
 }
 ```
 
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.
+
+### Space Optimal
+> TODO: `O(1)` space complexity.
+
 > Take a look at another solution (using the `next` pointer just built): https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/solution/tian-chong-mei-ge-jie-dian-de-xia-yi-ge-you-ce-2-4/

leetcode/128.longest-consecutive-sequence.md

@@ -15,6 +15,8 @@ fun longestConsecutive(nums: IntArray): Int {
     for (i in 0 until nums.size) {
         val num = nums[i]
         // This is the key, we only check ascending direction.
+        // We're looking for the start sequence and it has not "left number" (num - 1)
+
         // If we have num - 1 which is consecutive to num, answer will check at num - 1 iteration, not current iteration.
         if (!hashSet.contains(num - 1)) {
             var next = num + 1

leetcode/1325.delete-leaves-with-a-given-value.md

@@ -0,0 +1,64 @@
+## [1325. Delete Leaves With a Given Value](https://leetcode.com/problems/delete-leaves-with-a-given-value)
+
+### Recursive
+For problem statement `Note that once you delete a leaf node with value target, if its parent node becomes a leaf node and has the value target, it should also be deleted`, so we have to process the child first, when we've done, we check the root to see if that becomes the leaf and if to delete or not. (Postorder)
+
+```kotlin
+fun removeLeafNodes(root: TreeNode?, target: Int): TreeNode? {
+    if (root == null) return null
+    root.left = removeLeafNodes(root.left, target)
+    root.right = removeLeafNodes(root.right, target)
+
+    if (root.left == null && root.right == null && root.`val` == target) {
+        return null
+    }
+    return root
+}
+```
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(h)`.
+
+
+### Iterative
+```kotlin
+fun removeLeafNodes(root: TreeNode?, target: Int): TreeNode? {
+    if (root == null) return null
+    val parentMap = hashMapOf<TreeNode, TreeNode>()
+    val queue = ArrayDeque<TreeNode>()
+    val leafs = mutableListOf<TreeNode>()
+    queue.addLast(root)
+    while (queue.isNotEmpty()) {
+        val node = queue.removeFirst()
+        if (node.left == null && node.right == null) {
+            leafs.add(node)
+            continue
+        }
+        if (node.left != null) {
+            queue.addLast(node.left)
+            parentMap[node.left] = node
+        }
+        if (node.right != null) {
+            queue.addLast(node.right)
+            parentMap[node.right] = node
+        }
+    }
+
+    for (leaf in leafs) {
+        var current = leaf
+        var parent = parentMap[current]
+        while (current.`val` == target && current.left == null && current.right == null) {
+            if (parent == null) return null
+            
+            if (current == parent!!.left) parent!!.left = null
+            else parent!!.right = null
+
+            current = parent!!
+            parent = parentMap[parent!!]
+        }
+    }
+    return root
+}
+```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.