Added tasks 107, 108, 109, 110.

Author: ThanhNIT

README.md

@@ -560,6 +560,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0110 |[Balanced Binary Tree](src/main/kotlin/g0101_0200/s0110_balanced_binary_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 398 | 12.89
 
 #### Day 3
 
@@ -916,6 +917,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 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
+| 0110 |[Balanced Binary Tree](src/main/kotlin/g0101_0200/s0110_balanced_binary_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 398 | 12.89
 
 #### Day 7 Tree
 
@@ -935,6 +937,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0108 |[Convert Sorted Array to Binary Search Tree](src/main/kotlin/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/Solution.kt)| Easy | Top_Interview_Questions, Array, Tree, Binary_Tree, Binary_Search_Tree, Divide_and_Conquer | 334 | 35.39
 | 0230 |[Kth Smallest Element in a BST](src/main/kotlin/g0201_0300/s0230_kth_smallest_element_in_a_bst/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 393 | 33.33
 
 #### Day 10 Graph/BFS/DFS
@@ -1109,10 +1112,12 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 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
+| 0108 |[Convert Sorted Array to Binary Search Tree](src/main/kotlin/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/Solution.kt)| Easy | Top_Interview_Questions, Array, Tree, Binary_Tree, Binary_Search_Tree, Divide_and_Conquer | 334 | 35.39
 | 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
+| 0110 |[Balanced Binary Tree](src/main/kotlin/g0101_0200/s0110_balanced_binary_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 398 | 12.89
 | 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
@@ -1353,6 +1358,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0108 |[Convert Sorted Array to Binary Search Tree](src/main/kotlin/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/Solution.kt)| Easy | Top_Interview_Questions, Array, Tree, Binary_Tree, Binary_Search_Tree, Divide_and_Conquer | 334 | 35.39
 | 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
 
@@ -1534,6 +1540,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 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
+| 0110 |[Balanced Binary Tree](src/main/kotlin/g0101_0200/s0110_balanced_binary_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Programming_Skills_II_Day_2, Level_2_Day_6_Tree, Udemy_Tree_Stack_Queue | 398 | 12.89
+| 0109 |[Convert Sorted List to Binary Search Tree](src/main/kotlin/g0101_0200/s0109_convert_sorted_list_to_binary_search_tree/Solution.kt)| Medium | Tree, Binary_Tree, Linked_List, Binary_Search_Tree, Divide_and_Conquer | 376 | 59.26
+| 0108 |[Convert Sorted Array to Binary Search Tree](src/main/kotlin/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/Solution.kt)| Easy | Top_Interview_Questions, Array, Tree, Binary_Tree, Binary_Search_Tree, Divide_and_Conquer, Data_Structure_II_Day_15_Tree, Level_2_Day_9_Binary_Search_Tree, Udemy_Tree_Stack_Queue | 334 | 35.39
+| 0107 |[Binary Tree Level Order Traversal II](src/main/kotlin/g0101_0200/s0107_binary_tree_level_order_traversal_ii/Solution.kt)| Medium | Breadth_First_Search, Tree, Binary_Tree | 409 | 6.82
 | 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

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

@@ -0,0 +1,38 @@
+package g0101_0200.s0107_binary_tree_level_order_traversal_ii
+
+// #Medium #Breadth_First_Search #Tree #Binary_Tree
+// #2022_09_28_Time_409_ms_(6.82%)_Space_36.6_MB_(72.73%)
+
+import com_github_leetcode.TreeNode
+import java.util.Collections
+import kotlin.collections.ArrayList
+
+/**
+ * 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 val order: MutableList<MutableList<Int>> = ArrayList()
+    fun levelOrderBottom(root: TreeNode?): List<MutableList<Int>> {
+        getOrder(root, 0)
+        Collections.reverse(order)
+        return order
+    }
+
+    fun getOrder(root: TreeNode?, level: Int) {
+        if (root != null) {
+            if (level + 1 > order.size) {
+                order.add(ArrayList())
+            }
+            order[level].add(root.`val`)
+            getOrder(root.left, level + 1)
+            getOrder(root.right, level + 1)
+        }
+    }
+}

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

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

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

@@ -0,0 +1,39 @@
+package g0101_0200.s0108_convert_sorted_array_to_binary_search_tree
+
+// #Easy #Top_Interview_Questions #Array #Tree #Binary_Tree #Binary_Search_Tree #Divide_and_Conquer
+// #Data_Structure_II_Day_15_Tree #Level_2_Day_9_Binary_Search_Tree #Udemy_Tree_Stack_Queue
+// #2022_09_28_Time_334_ms_(35.39%)_Space_36.9_MB_(92.05%)
+
+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 sortedArrayToBST(num: IntArray): TreeNode? {
+        /*1. Set up recursion*/
+        return makeTree(num, 0, num.size - 1)
+    }
+
+    private fun makeTree(num: IntArray, left: Int, right: Int): TreeNode? {
+        /*2. left as lowest# can't be greater than right*/
+        if (left > right) {
+            return null
+        }
+        /*3. Set median# as node*/
+        val mid = (left + right) / 2
+        val midNode = TreeNode(num[mid])
+        /*4. Set mid node's kids*/
+        midNode.left = makeTree(num, left, mid - 1)
+        midNode.right = makeTree(num, mid + 1, right)
+        /*5. Sends node back || Goes back to prev node*/
+        return midNode
+    }
+}

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

@@ -0,0 +1,33 @@
+108\. Convert Sorted Array to Binary Search Tree
+
+Easy
+
+Given an integer array `nums` where the elements are sorted in **ascending order**, convert _it to a **height-balanced** binary search 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.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg)
+
+**Input:** nums = [-10,-3,0,5,9]
+
+**Output:** [0,-3,9,-10,null,5]
+
+**Explanation:** [0,-10,5,null,-3,null,9] is also accepted: ![](https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg)
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/btree.jpg)
+
+**Input:** nums = [1,3]
+
+**Output:** [3,1]
+
+**Explanation:** [1,null,3] and [3,1] are both height-balanced BSTs.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `nums` is sorted in a **strictly increasing** order.

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

@@ -0,0 +1,58 @@
+package g0101_0200.s0109_convert_sorted_list_to_binary_search_tree
+
+// #Medium #Tree #Binary_Tree #Linked_List #Binary_Search_Tree #Divide_and_Conquer
+// #2022_09_28_Time_376_ms_(59.26%)_Space_43.3_MB_(66.67%)
+
+import com_github_leetcode.ListNode
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+/*
+ * 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 sortedListToBST(head: ListNode?): TreeNode? {
+        // Empty list -> empty tree / sub-tree
+        if (head == null) {
+            return null
+        }
+        // No next node -> this node will become leaf
+        if (head.next == null) {
+            val leaf = TreeNode(head.`val`)
+            leaf.left = null
+            leaf.right = null
+            return leaf
+        }
+        var slow = head
+        // Head-Start fast by 1 to get slow = mid -1
+        var fast = head.next!!.next
+        // Find the mid of list
+        while (fast != null && fast.next != null) {
+            slow = slow!!.next
+            fast = fast.next!!.next
+        }
+        // slow.next ->  mid = our "root"
+        val root = TreeNode(slow!!.next!!.`val`)
+        // Right sub tree from mid - end
+        root.right = sortedListToBST(slow.next!!.next)
+        // Left sub tree from head - mid (chop slow.next)
+        slow.next = null
+        root.left = sortedListToBST(head)
+        return root
+    }
+}

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

@@ -0,0 +1,28 @@
+109\. Convert Sorted List to Binary Search Tree
+
+Medium
+
+Given the `head` of a singly linked list where elements are **sorted in ascending order**, convert it to a height balanced BST.
+
+For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of _every_ node never differ by more than 1.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/17/linked.jpg)
+
+**Input:** head = [-10,-3,0,5,9]
+
+**Output:** [0,-3,9,-10,null,5]
+
+**Explanation:** One possible answer is [0,-3,9,-10,null,5], which represents the shown height balanced BST.
+
+**Example 2:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in `head` is in the range <code>[0, 2 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>

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

@@ -0,0 +1,62 @@
+package g0101_0200.s0110_balanced_binary_tree
+
+// #Easy #Depth_First_Search #Tree #Binary_Tree #Programming_Skills_II_Day_2 #Level_2_Day_6_Tree
+// #Udemy_Tree_Stack_Queue #2022_09_28_Time_398_ms_(12.89%)_Space_43.8_MB_(12.58%)
+
+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 isBalanced(root: TreeNode?): Boolean {
+        // Empty Tree is balanced
+        if (root == null) {
+            return true
+        }
+        // Get max height of subtree child
+        // Get max height of subtree child
+        // compare height difference (cannot be more than 1)
+        var leftHeight = 0
+        var rightHeight = 0
+        if (root.left != null) {
+            leftHeight = getMaxHeight(root.left)
+        }
+        if (root.right != null) {
+            rightHeight = getMaxHeight(root.right)
+        }
+        val heightDiff = Math.abs(leftHeight - rightHeight)
+        // if passes height check
+        //  - Check if left subtree is balanced and if the right subtree is balanced
+        //  - If one of both are imbalanced, then the tree is imbalanced
+        return heightDiff <= 1 && isBalanced(root.left) && isBalanced(root.right)
+    }
+
+    private fun getMaxHeight(root: TreeNode?): Int {
+        if (root == null) {
+            return 0
+        }
+        var leftHeight = 0
+        var rightHeight = 0
+        // Left
+        if (root.left != null) {
+            leftHeight = getMaxHeight(root.left)
+        }
+        // Right
+        if (root.right != null) {
+            rightHeight = getMaxHeight(root.right)
+        }
+        return if (leftHeight > rightHeight) {
+            1 + leftHeight
+        } else {
+            1 + rightHeight
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+110\. Balanced Binary Tree
+
+Easy
+
+Given a binary tree, determine if it is height-balanced.
+
+For this problem, a height-balanced binary tree is defined as:
+
+> a binary tree in which the left and right subtrees of _every_ node differ in height by no more than 1.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg)
+
+**Input:** root = [1,2,2,3,3,null,null,4,4]
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** true
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 5000]`.
+*   <code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code>