Update notes of tree problems and split tree problem out

Author: enginebai

README.md

@@ -22,7 +22,7 @@ This project offers a curated collection of notes and resources covering fundame
 - [Backtracking](./topics/backtracking.md)
 
 ## Problems & Solutions
-- [LeetCode Solutions](./topics/leetcode-solutions.md)
+- [LeetCode Problem Listing](./leetcode/README.md)
 - [Problem Solving Techniques](./topics/problem-solving.md)
 
 ## Roadmap

leetcode/100.same-tree.md

@@ -1,4 +1,4 @@
-## [100. Same Tree](https://leetcode.com/problems/same-tree/)
+# [100. Same Tree](https://leetcode.com/problems/same-tree/)
 
 ## Clarification Questions
 * No, it's clear from problem description.
@@ -7,16 +7,41 @@
 ### Normal Cases
 ```
 Input: 
-Output: 
+    1
+  /   \
+ 2     3
+
+    1
+  /   \
+ 2     3
+Output: True
 ```
 ### Edge / Corner Cases
-* 
+* Values are the same, but different structurely.
+```
+Input: 
+    1
+  /   
+ 2  
+    1
+      \
+       2
+Output = False
+```
+
+* Same structurely, but different value.
 ```
 Input: 
-Output: 
+    1
+  /   
+ 2  
+    1
+  /   
+ 3
+Output = False
 ```
 
-### Recursive
+## Recursive
 ```kotlin
 fun isSameTree(p: TreeNode?, q: TreeNode?): Boolean {
     if (p == null && q == null) return true
@@ -25,15 +50,15 @@ 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|))`
+* **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
+## Traversal
 ```kotlin
 class Solution {
 
-    private val pNodes = mutableListOf<Int>()
-    private val qNodes = mutableListOf<Int>()
+    private val pNodes = mutableListOf<Int?>()
+    private val qNodes = mutableListOf<Int?>()
 
     fun isSameTree(p: TreeNode?, q: TreeNode?): Boolean {
         inOrderTraversal(p, pNodes)
@@ -48,17 +73,14 @@ class Solution {
         return true
     }
 
-    private fun inOrderTraversal(node: TreeNode?, results: MutableList<Int>) {
-        results.add(node?.`val` ?: Int.MAX_VALUE)
-        if (node?.left != null) inOrderTraversal(node?.left, results) else results.add(Int.MAX_VALUE)
-        if (node?.right != null) inOrderTraversal(node?.right, results) else results.add(Int.MAX_VALUE)
+    private fun inOrderTraversal(node: TreeNode?, results: MutableList<Int?>) {
+        results.add(node?.`val`)
+        // We can't skip the null node, we have to add null value for it.
+        if (node?.left != null) inOrderTraversal(node?.left, results) else results.add(null)
+        if (node?.right != null) inOrderTraversal(node?.right, results) else results.add(null)
     }
 }
 ```
 
-### Failed Cases
-```js
-[1, 2]
-[1, null, 2]
-```
-I skip the null node, so two trees are content identical, not structurely. Can't skip the null node.
+* **Time Complexity**: `O(max(P, Q))`, where `|P|` and `|Q|` are the number of tree nodes of `p` and `q`.
+* **Space Complexity**: `O(P + Q)`

leetcode/101.symmetric-tree.md

@@ -1,4 +1,4 @@
-## [101. Symmetric Tree](https://leetcode.com/problems/symmetric-tree/)
+# [101. Symmetric Tree](https://leetcode.com/problems/symmetric-tree/)
 
 ## Clarification Questions
 * Is the empty tree symmetric?
@@ -31,45 +31,45 @@ Input:
     3
 Output: False
 ```
-### Recursive
+
+## Recursive
 ```kotlin
 fun isSymmetric(root: TreeNode?): Boolean {
     if (root == null) return true
     return check(root?.left, root?.right)
 }
 
 fun check(left: TreeNode?, right: TreeNode?): Boolean {
-    if (left == null || right == null) return left == right
-    if (left?.`val` != right?.`val`) return false
-    return check(left?.left, right?.right) && check(left?.right, right?.left)
+    if (left == null && right == null) return true
+    if (left == null || right == null) return false
+    return (left?.`val` == right?.`val`) && check(left?.left, right?.right) && check(left?.right, right?.left)
 }
 ```
 
-### Iterative
+## Iterative
 ```kotlin
-private val nullNode = TreeNode(200)
-    
 fun isSymmetric(root: TreeNode?): Boolean {
     if (root == null) return true
 
-    val leftQueue = ArrayDeque<TreeNode>()
-    val rightQueue = ArrayDeque<TreeNode>()
+    val leftQueue = ArrayDeque<TreeNode?>()
+    val rightQueue = ArrayDeque<TreeNode?>()
 
-    leftQueue.addLast(root.left ?: nullNode)        
-    rightQueue.addLast(root.right ?: nullNode)
+    leftQueue.addLast(root.left)        
+    rightQueue.addLast(root.right)
 
     while (leftQueue.isNotEmpty() && rightQueue.isNotEmpty()) {
         val left = leftQueue.removeFirst()
         val right = rightQueue.removeFirst()
-        if (left == nullNode && right == nullNode) continue
-        if (left == nullNode || right == nullNode) return false
+        if (left == null && right == null) continue
+        if (left == null || right == null) return false
 
         if (left.`val` != right.`val`) return false
 
-        leftQueue.addLast(if (left.left != null) left.left else nullNode)
-        rightQueue.addLast(if (right.right != null) right.right else nullNode)
-        leftQueue.addLast(if (left.right != null) left.right else nullNode)
-        rightQueue.addLast(if (right.left != null) right.left else nullNode)
+        leftQueue.addLast(left.left)
+        rightQueue.addLast(right.right)
+
+        leftQueue.addLast(left.right)
+        rightQueue.addLast(right.left)
     }
 
     return leftQueue.isEmpty() && rightQueue.isEmpty()

leetcode/110.balanced-binary-tree.md

@@ -1,34 +1,94 @@
-## [110. Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/)
+# [110. Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/)
+
+A height-balanced binary tree is a binary tree in which **the depth of the two subtrees of every node never differs by more than one**. 
+
+## Clarification Questions
+* Is the empty tree balanced?
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+        1
+      /   \
+     2     2
+          / \
+         3   4
+Output: True
+
+Input: 
+        1
+      /   \
+     2     2
+            \
+             4
+Output: False
+```
+### Edge / Corner Cases
+```
+Input: 
+        1
+      /   \
+     2     2
+    /       \
+   5         4
+Output: True
+
+Input: 
+        1
+      /   \
+     2     2
+    /       \
+   5         4
+  /           \
+ 6             7
+Output: False
+
+Input:
+        1
+      /   \
+     2     2
+    /     / \
+   1     3   4
+  /     /
+ 0     5
+      /
+     6
+Output: False
+```
 
 ### Top-Down Recursion
+We can iterate each node recursively to check if the height of their subtree differs <= 1. For each node, we calculate the height of subtree (one recursion), and check the current difference with the check of two subtrees recursively (another recursion).
 ```kotlin
 fun isBalanced(root: TreeNode?): Boolean {
     if (root == null) return true
-    val leftHeight = height(root?.left)
-    var rightHeight = height(root?.right)
+    val leftHeight = getHeight(root?.left)
+    var rightHeight = getHeight(root?.right)
     val diff = leftHeight - rightHeight
     return diff * diff <= 1 && isBalanced(root?.left) && isBalanced(root?.right)
 }
 
-private fun height(node: TreeNode?): Int {
+private fun getHeight(node: TreeNode?): Int {
     return if (node == null) 0
     else {
-        1 + maxOf(height(node?.left), height(node?.right))
+        1 + maxOf(getHeight(node?.left), getHeight(node?.right))
     }
 }
 ```
 
-* **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)`.
+* **Time Complexity**: Calculate the height takes `O(h)`, and we have to calculate every node `n`, total takes `O(n * h)`, in the average case (every node has children) we have `O(n log n)`, but the worst case is `O(n^2)` when the tree is skewed because the height becomes `O(n)`.
+* **Space Complexity**: `O(n)` for recursive call stack.
 
 > 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 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.
+From previous solution, we invoke `isBalanced()` for each node recursively, and for each `isBalanced()` we have to calculate the height `getHeight()` recursively which leads to `O(n^2)` time complexity. Here we can optimize the solution by changing (merging) the purpose of `getHeight()`. We still use `getHeight()` to calculate the height, and use this function to indicate if the subtree is height-balanced at the same time.
+* If it's height-balanced, then return the height of current subtree.
+* Otherwise, just return -1 to indicate unbalanced. If it's not balanced from its child node, then the current node is not balanced as well.
 
 ![](../media/110.balanced-binary-tree.png)
-> Source: [Solution](https://leetcode.cn/problems/balanced-binary-tree/solution/ping-heng-er-cha-shu-by-leetcode-solution/), please take a very close look at it explanation.
+> Source: [Solution](https://leetcode.cn/problems/balanced-binary-tree/solution/ping-heng-er-cha-shu-by-leetcode-solution/)
+
 ```kotlin
 fun isBalanced(root: TreeNode?): Boolean {
     return getHeight(root) != -1
@@ -40,21 +100,10 @@ private fun getHeight(root: TreeNode?): Int {
     val leftHeight = getHeight(root.left)
     val rightHeight = getHeight(root.right)
 
+    // If one of the subtrees is not balanced, the it's not balanced overall
     if (leftHeight == -1 || rightHeight == -1 || abs(leftHeight - rightHeight) > 1) return -1
     else return 1 + max(leftHeight, rightHeight)
 }
 ```
 * **Time Complexity**: It becomes `O(n)` since we calculate the height only once for every node.
 * **Space Complexity**: `O(n)`.
-
-### Special Cases
-It's not balanced.
-```js
-        1
-       / \
-      2   3
-     /     \
-    4       5
-   /         \
-  5           7
-```

leetcode/112.path-sum.md

@@ -1,4 +1,4 @@
-## [112. Path Sum](https://leetcode.com/problems/path-sum/)
+# [112. Path Sum](https://leetcode.com/problems/path-sum/)
 
 ## Clarification Questions
 * No, it's clear from problem description.
@@ -7,15 +7,29 @@
 ### Normal Cases
 ```
 Input: 
-Output: 
+    1
+  /   \
+ 3     4
+targetSum = 4
+
+Output: True
+
+Input:
+    1
+  /   \
+ 3     4
+targetSum = 6
+
+Output: False
 ```
 ### Edge / Corner Cases
-* 
+* Empty tree
 ```
-Input: 
-Output: 
+Input: []
+Output: False 
 ```
 
+## DFS
 ```kotlin
 fun hasPathSum(root: TreeNode?, targetSum: Int): Boolean {
     if (root == null) return false