Add and update some binary tree and BST notes and problem solving solutions

Author: enginebai

leetcode/1038.binary-search-tree-to-greater-sum-tree.md

@@ -0,0 +1,101 @@
+# [1038. Binary Search Tree to Greater Sum Tree](https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/description/)
+
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* The greater value of the node comes from parent node. Or the smaller value of the node goes to parent node.
+```
+         4(23)
+           \
+            6(14)
+           /    \   
+          5(19)  8(8)
+
+
+        4(4)
+       /
+      1(10)
+       \
+        2(9)
+          \
+           3(7)
+```
+
+# Approach
+We only think about what to do in current root node, other nodes are handled by recursion. For the current root node:
+1. It will receive the sum of all nodes greater than itself. (The parameter of our recursive function)
+2. We convert the right child to a greater sum tree in bottom-up manner. 
+3. After conver the right child, we will get the sum of all nodes greater than the right child. `rightSum`.
+4. We update the current root node value to `root.val + rightSum`.
+5. We convert the left child to a greater sum tree in top-down manner with `root.val + rightSum` as the parameter.
+6. Return the sum of root node and all its children as the next greater sum.
+
+```kotlin
+fun bstToGst(root: TreeNode?): TreeNode? {
+    if (root == null) return null
+    build(root, 0)
+    return root
+}
+
+private fun build(root: TreeNode?, value: Int): Int {
+    // If the root is null, return the value, not 0. It indicates that we
+    // don't update the value of the current node.
+    if (root == null) return value
+
+    // Build right child from bottom up approach
+    //     4(4)
+    //    /
+    //   1
+    //    \
+    //     2
+    //      \
+    //       3(7) We have to pass value 4 to node 3.
+    var rightSum = build(root.right, value)
+
+    // We update from the result of right child
+    var currentSum = root.`val` + rightSum
+    root.`val` = currentSum
+
+    // Build left child from top down approach with new sum
+    currentSum = build(root.left, currentSum)
+
+    // Why should we return currentSum? Because we need to return the sum of
+    // the current node and all its children. Not just the current node.
+    // For example, the tree below:
+    //   4 
+    //    \
+    //     6(14) // here we should return 19 to the parent node (4)., not 14.
+    //   /     \
+    //  5(19)  8(8)
+    //
+    // Root 4 will receive 19, not 14. Because 21 is the sum of 5, 6, 8.
+    return currentSum
+}
+
+// Or equivalently, we can maintain a global variable to store the sum.
+private var sum = 0
+  fun bstToGst(root: TreeNode?): TreeNode? {
+      inorder(root)
+      return root
+  }
+
+  private fun inorder(root: TreeNode?) {
+      if (root == null) return
+      // We traverse the right subtree first, then the root, and then the left subtree.
+      
+      inorder(root.right)
+      sum += root.`val`
+      root.`val` = sum
+      inorder(root.left)
+  }
+```
+
+* **Time Complexity:** `O(n)`, where `n` is the number of nodes in the tree.
+* **Space Complexity:** `O(h)`

leetcode/104.maximum-depth-of-binary-tree.md

@@ -34,16 +34,16 @@ fun maxDepth(root: TreeNode?): Int {
     // Empty tree
     if (root == null) return 0
 
-    // Leaf node
+    // Leaf node (optional)
     if (root.left == null && root.right == null) return 1
 
     // Node with one or two children
     return 1 + maxOf(maxDepth(root.left), maxDepth(root.right))
 }
 ```
 
-* **Time Complexity**: `O(n)`, iterate all nodes.
-* **Space Complextiy**: `O(h)`, height might be `lg n` (balanced) or `n` (skewed)
+* **Time Complexity**: `O(n)`, we traverse all nodes once.
+* **Space Complextiy**: `O(H)`, recursion need space for stack, and the space depends on the height of the tree. The height might be `lg n` (balanced) or `n` (skewed)
 
 ### BFS
 ```kotlin
@@ -64,5 +64,5 @@ fun maxDepth(root: TreeNode?): Int {
     return depth
 }
 ```
-* **Time Complexity**: `O(n)`, iterate all nodes.
-* **Space Complexity**: `O(n)`, iterate all nodes.
+* **Time Complexity**: `O(n)`, we traverse all nodes once.
+* **Space Complexity**: `O(n)`, we traverse all nodes in queue.

leetcode/105.construct-binary-tree-from-preorder-and-inorder-traversal.md

@@ -15,12 +15,25 @@ Input:
 Output: 
 ```
 
+## Recursive
 ```js
-Preorder = [D L R]
-Inorder = [L D R]
+Preorder =  [D L R]
+            [D [X, X, X] [Y, Y, Y]]
+             | [Left]    [Right]
+             |
+             Root
+
+Inorder =   [L D R]
+            [[X, X, X] D [Y, Y, Y]]
+             [Left]    | [Right]
+                       |
+                       Root
 ```
 
-You locate the `D` at first, then get the range of left subtree from inorder based on the `D` index, the remaining part is right subtree.
+1. You locate the `D` at first which is root from preorder.
+2. Then search for the `D` in inorder. 
+3. The left part of `D` in inorder is left subtree. 
+4. The right part of `D` in inorder is right subtree. Or you can get the size of left subtree from inorder, then total size subtracted by left subtree size and root is right subtree size.
 
 ```kotlin
 fun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {
@@ -40,4 +53,7 @@ fun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {
     root.right = buildTree(rightInPreorder, rightInInOrder)
     return root
 }
-```
+```
+
+* **Time Complexity:** `O(n)` where `n` is the number of nodes in the tree.
+* **Space Complexity:** `O(n)` where `n` is the number of nodes in the tree.

leetcode/112.path-sum.md

@@ -38,6 +38,36 @@ fun hasPathSum(root: TreeNode?, targetSum: Int): Boolean {
         return hasPathSum(root.left, targetSum - root.`val`) || hasPathSum(root.right, targetSum - root.`val`)
     }
 }
+
+// Or equivalently, we can add up to target sum:
+fun hasPathSum(root: TreeNode?, targetSum: Int): Boolean {
+    return pathSum(root, 0, targetSum)
+}
+
+private fun pathSum(root: TreeNode?, sum: Int, target: Int): Boolean {
+    if (root == null) return false
+    if (root.left == null && root.right == null) {
+        return sum + root.`val` == target
+    }
+
+    return pathSum(root.left, sum + root.`val`, target) ||
+            pathSum(root.right, sum + root.`val`, target)
+}
+
+// root: The current node we are processing now
+// currentSum: The sum before processing the current node
+private fun dfs(root: TreeNode?, sum: Int) {
+    if (root == null) return
+
+    // Process current node
+    val currentSum = sum + root.`val`
+
+    // Do something with the current node
+
+    // Child nodes
+    dfs(root.left, currentSum)
+    dfs(root.right, currentSum)
+}
 ```
 
 * **Time Complexity**: `O(n)`.

leetcode/114.flatten-binary-tree-to-linked-list.md

@@ -147,38 +147,7 @@ private fun subtreeLast(root: TreeNode): TreeNode {
 * **Time Complexity**: `O(n)`, where `n` is the node of tree.
 * **Space Complexity**: `O(h)`, where `h` is the height of tree.
 
-## Postorder (DFS)
-We can use postorder traversal to flatten the tree. The idea is to flatten the left subtree and right subtree first, then we relink the right subtree after the right most node of left subtree.
-
-![](../media/114.flatten-binary-tree-to-linked-list.png)
-
-```kotlin
-fun flatten(root: TreeNode?) {
-    if (root == null) return
-
-    val left = root.left
-    val right = root.right
-    flatten(left)
-    flatten(right)
-
-    // We relink onlyl when left child is not null, 
-    // otherwise, we will override right child with null.
-    if (left != null) {
-        root.right = left
-        root.left = null
-
-        val rightOfLeft = subtreeLast(left)
-        rightOfLeft?.right = right
-    }
-}
-
-private fun subtreeLast(node: TreeNode?): TreeNode? {
-    return if (node?.right != null) subtreeLast(node.right!!)
-    else node
-}
-```
-
-## Postorder with Pointers (Space Optimization)
+## Preorder with Pointers (Space Optimization)
 Idea is the same, but we traversal with pointers only (removing stack or recursion).
 
 ```kotlin
@@ -210,7 +179,42 @@ private fun subtreeLast(root: TreeNode?): TreeNode? {
 }
 ```
 
-### Dry Run (Postorder with Pointers)
+* **Time Complexity**: `O(n)`, where `n` is the node of tree.
+* **Space Complexity**: `O(1)`.
+
+## Postorder
+We can use postorder traversal to flatten the tree. The idea is to flatten the left subtree and right subtree first, then we relink the right subtree after the right most node of left subtree.
+
+![](../media/114.flatten-binary-tree-to-linked-list.png)
+
+```kotlin
+fun flatten(root: TreeNode?) {
+    if (root == null) return
+
+    val left = root.left
+    val right = root.right
+    flatten(left)
+    flatten(right)
+
+    // We relink onlyl when left child is not null, 
+    // otherwise, we will override right child with null.
+    if (left != null) {
+        root.right = left
+        root.left = null
+
+        val rightOfLeft = subtreeLast(left)
+        rightOfLeft?.right = right
+    }
+}
+
+private fun subtreeLast(node: TreeNode?): TreeNode? {
+    return if (node?.right != null) subtreeLast(node.right!!)
+    else node
+}
+```
+
+
+### Dry Run (Preorder with Pointers)
 ```kotlin
         1
      /     \

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

@@ -47,6 +47,12 @@ fun connect(root: Node?): Node? {
 
 
 ## Recursive
+We can start connecting two nodes, and for each two nodes, we can connect their children nodes.
+
+> 传统的 traverse 函数是遍历二叉树的所有节点，但现在我们想遍历的其实是两个相邻节点之间的「空隙」。这样我们就可以通过这两个节点的 next 指针将它们连接起来。
+![](https://labuladong.online/algo/images/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%B3%BB%E5%88%97/3.png)
+>
+> Nice explanation & Source: https://labuladong.online/algo/data-structure/binary-tree-part1/#%E7%AC%AC%E4%BA%8C%E9%A2%98%E3%80%81%E5%A1%AB%E5%85%85%E8%8A%82%E7%82%B9%E7%9A%84%E5%8F%B3%E4%BE%A7%E6%8C%87%E9%92%88
 ```kotlin
 /**
  *        1

leetcode/124.binary-tree-maximum-path-sum.md

@@ -60,41 +60,40 @@ Meanwhile, we can update the global maximum path sum, which will be one of the c
 2. Left + Root + Right
 
 ```kotlin
-class Solution {
-    
-    private var result = Int.MIN_VALUE
-    
-    fun maxPathSum(root: TreeNode?): Int {
-        calculateMax(root)
-        return result
-    }
-    
-    private fun calculateMax(root: TreeNode?): Int {
-        if (root == null) return 0
-        val left = calculateMax(root?.left)
-        val right = calculateMax(root?.right)
-        val current = root.`val`
-    
-        // Global max should calcluate from
-        //      Root
-        //     /    \
-        //   Left  Right
-        // Root
-        // Root + Left
-        // Root + Right
-        // Root + Left + Right
-        result = maxOf(result, value)
-        result = maxOf(result, value + left)
-        result = maxOf(result, value + right)
-        result = maxOf(result, value + left + right)
-
-        // Current path sum should contains at least the value of current node, so it should be from
-        // Root
-        // Root + Left
-        // Root + Right
-        return maxOf(value, maxOf(value + left, value + right))
-    }
-}
+  private var globalMax = Int.MIN_VALUE
+
+  fun maxPathSum(root: TreeNode?): Int {
+      pathSum(root)
+      return globalMax
+  }
+
+  private fun pathSum(root: TreeNode?): Int {
+      if (root == null) return 0
+
+      val leftSum = pathSum(root.left)
+      val rightSum = pathSum(root.right)
+
+      // Local max is the return value of this function, which includes
+      // Root
+      // Root + Left
+      // Root + Right
+      var localMax = root.`val`
+      localMax = maxOf(localMax, root.`val` + leftSum)
+      localMax = maxOf(localMax, root.`val` + rightSum)
+
+      // Global max should calcluate from
+      //      Root
+      //     /    \
+      //   Left  Right
+      // Root                 (local max)
+      // Root + Left          (local max)
+      // Root + Right         (local max)
+      // Root + Left + Right
+      globalMax = maxOf(globalMax, localMax)
+      globalMax = maxOf(globalMax, root.`val` + leftSum + rightSum)
+
+      return localMax
+  }
 ```
 
 * **Time Complexity**: `O(n)`.