Merge pull request ByteByteGoHq#41 from marttp/kotlin-tree

Kotlin - Chapter 11: Trees

Author: Destiny-02

kotlin/Trees/BalancedBinaryTreeValidation.kt

@@ -0,0 +1,36 @@
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int, 
+        var left: TreeNode? = null, 
+        var right: TreeNode? = null
+    )
+*/
+
+fun balancedBinaryTreeValidation(root: TreeNode?): Boolean {
+    return getHeightImbalance(root) != -1
+}
+
+fun getHeightImbalance(node: TreeNode?): Int {
+    // Base case: if the node is null, its height is 0.
+    if (node == null) {
+        return 0
+    }
+    // Recursively get the height of the left and right subtrees. If
+    // either subtree is imbalanced, propagate -1 up the tree.
+    val leftHeight = getHeightImbalance(node.left)
+    val rightHeight = getHeightImbalance(node.right)
+    if (leftHeight == -1 || rightHeight == -1) {
+        return -1
+    }
+    // If the current node's subtree is imbalanced
+    // (height difference > 1), return -1.
+    if (Math.abs(leftHeight - rightHeight) > 1) {
+        return -1
+    }
+    // Return the height of the current subtree.
+    return 1 + Math.max(leftHeight, rightHeight)
+}

kotlin/Trees/BinarySearchTreeValidation.kt

@@ -0,0 +1,36 @@
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int,
+        var left: TreeNode? = null,
+        var right: TreeNode? = null
+    )
+*/
+
+fun binarySearchTreeValidation(root: TreeNode?): Boolean {
+    // Start validation at the root node. The root node can contain any
+    // value, so set the initial lower and upper bounds to -infinity and
+    // +infinity, respectively.
+    return isWithinBounds(root, Int.MIN_VALUE, Int.MAX_VALUE)
+}
+
+fun isWithinBounds(node: TreeNode?, lowerBound: Int, upperBound: Int): Boolean {
+    // Base case: if the node is null, it satisfies the BST condition.
+    if (node == null) {
+        return true
+    }
+    // If the current node's value is not within the valid bounds, this
+    // tree is not a valid BST.
+    if (node.value <= lowerBound || node.value >= upperBound) {
+        return false
+    }
+    // If the left subtree isn't a BST, this tree isn't a BST.
+    if (!isWithinBounds(node.left, lowerBound, node.value)) {
+        return false
+    }
+    // Otherwise, return true if the right subtree is also a BST.
+    return isWithinBounds(node.right, node.value, upperBound)
+}

kotlin/Trees/BinaryTreeColumns.kt

@@ -0,0 +1,42 @@
+import java.util.LinkedList
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int,
+        var left: TreeNode? = null,
+        var right: TreeNode? = null
+    )
+*/
+
+fun binaryTreeColumns(root: TreeNode?): List<List<Int>> {
+    if (root == null) {
+        return emptyList()
+    }
+    val columnMap = hashMapOf<Int, MutableList<Int>>()
+    var leftmostColumn = 0
+    var rightmostColumn = 0
+    val queue = LinkedList<Pair<TreeNode?, Int>>()
+    queue.add(root to 0)
+
+    while (queue.isNotEmpty()) {
+        val (node, column) = queue.removeFirst()
+        if (node != null) {
+            // Add the current node's value to its corresponding list in the hash
+            // map.
+            columnMap.computeIfAbsent(column) { mutableListOf() }.add(node.value)
+            leftmostColumn = minOf(leftmostColumn, column)
+            rightmostColumn = maxOf(rightmostColumn, column)
+            // Add the current node's children to the queue with their respective
+            // column ids.
+            queue.add(node.left to column - 1)
+            queue.add(node.right to column + 1)
+        }
+    }
+    
+    // Construct the output list by collecting values from each column in the hash
+    // map in the correct order.
+    return (leftmostColumn..rightmostColumn).map { columnMap[it] ?: emptyList() }
+}

kotlin/Trees/BinaryTreeSymmetry.kt

@@ -0,0 +1,40 @@
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int,
+        var left: TreeNode? = null,
+        var right: TreeNode? = null
+    )
+*/
+
+fun binaryTreeSymmetry(root: TreeNode?): Boolean {
+    if (root == null) {
+        return true
+    }
+    return compareTrees(root.left, root.right)
+}
+
+fun compareTrees(node1: TreeNode?, node2: TreeNode?): Boolean {
+    // Base case: if both nodes are null, they're symmetric.
+    if (node1 == null && node2 == null) {
+        return true
+    }
+    // If one node is null and the other isn't, they aren't symmetric.
+    if (node1 == null || node2 == null) {
+        return false
+    }
+    // If the values of the current nodes don't match, trees aren't symmetric.
+    if (node1.value != node2.value) {
+        return false
+    }
+    // Compare the 'node1's left subtree with 'node2's right subtree. If these
+    // aren't symmetric, the whole tree is not symmetric.
+    if (!compareTrees(node1.left, node2.right)) {
+        return false
+    }
+    // Compare the 'node1's right subtree with 'node2's left subtree.
+    return compareTrees(node1.right, node2.left)
+}

kotlin/Trees/BuildBinaryTree.kt

@@ -0,0 +1,65 @@
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int,
+        var left: TreeNode? = null,
+        var right: TreeNode? = null
+    )
+*/
+
+fun buildBinaryTree(preorder: List<Int>, inorder: List<Int>): TreeNode? {
+    val inorderIndexesMap = hashMapOf<Int, Int>()
+    val preorderIndex = intArrayOf(0)
+    // Populate the hash map with the inorder values and their indexes.
+    for (i in inorder.indices) {
+        inorderIndexesMap[inorder[i]] = i
+    }
+    // Build the tree and return its root node.
+    return buildSubtree(0, inorder.size - 1, preorder, inorder, preorderIndex, inorderIndexesMap)
+}
+
+fun buildSubtree(
+        left: Int,
+        right: Int,
+        preorder: List<Int>,
+        inorder: List<Int>,
+        preorderIndex: IntArray,
+        inorderIndexesMap: Map<Int, Int>
+): TreeNode? {
+    // Base case: if no elements are in this range, return null.
+    if (left > right) {
+        return null
+    }
+    val value = preorder[preorderIndex[0]]
+    // Set 'inorderIndex' to the index of the same value pointed at by
+    // 'preorderIndex'.
+    val inorderIndex = inorderIndexesMap[value]!!
+    val node = TreeNode(value)
+    // Advance 'preorderIndex' so it points to the value of the next
+    // node to be created.
+    preorderIndex[0]++
+    // Build the left and right subtrees and connect them to the current
+    // node.
+    node.left =
+            buildSubtree(
+                    left,
+                    inorderIndex - 1,
+                    preorder,
+                    inorder,
+                    preorderIndex + 1,
+                    inorderIndexesMap
+            )
+    node.right =
+            buildSubtree(
+                    inorderIndex + 1,
+                    right,
+                    preorder,
+                    inorder,
+                    preorderIndex + inorderIndex - left + 1,
+                    inorderIndexesMap
+            )
+    return node
+}

kotlin/Trees/InvertBinaryTreeIteretive.kt

@@ -0,0 +1,33 @@
+import java.util.Stack
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int, 
+        var left: TreeNode? = null, 
+        var right: TreeNode? = null
+    )
+*/
+
+fun invertBinaryTreeIterative(root: TreeNode?): TreeNode? {
+    if (root == null) return null
+    val stack = Stack<TreeNode>()
+    stack.push(root)
+    while (stack.isNotEmpty()) {
+        val node = stack.pop()
+        // Swap the left and right subtrees of the current node.
+        val temp = node.left
+        node.left = node.right
+        node.right = temp
+        // Push the left and right subtrees onto the stack.
+        if (node.left != null) {
+            stack.push(node.left)
+        }
+        if (node.right != null) {
+            stack.push(node.right)
+        }
+    }
+    return root
+}

kotlin/Trees/InvertBinaryTreeRecursive.kt

@@ -0,0 +1,26 @@
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int, 
+        var left: TreeNode? = null, 
+        var right: TreeNode? = null
+    )
+*/
+
+fun invertBinaryTreeRecursive(root: TreeNode?): TreeNode? {
+    // Base case: If the node is null, there's nothing to invert.
+    if (root == null) {
+        return null
+    }
+    // Swap the left and right subtrees of the current node.
+    val temp = root.left
+    root.left = root.right
+    root.right = temp
+    // Recursively invert the left and right subtrees.
+    invertBinaryTreeRecursive(root.left)
+    invertBinaryTreeRecursive(root.right)
+    return root
+}

kotlin/Trees/KthSmallestNumberInBSTIterative.kt

@@ -0,0 +1,38 @@
+import java.util.Stack
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int,
+        var left: TreeNode? = null,
+        var right: TreeNode? = null
+    )
+*/
+
+fun kthSmallestNumberInBSTIterative(root: TreeNode?, k: Int): Int {
+    val stack = Stack<TreeNode>()
+    var node = root
+    // Copy 'k' to a mutable variable so we can decrement it.
+    var k = k
+    while (stack.isNotEmpty() || node != null) {
+        // Move to the leftmost node and add nodes to the stack as we go so they
+        // can be processed in future iterations.
+        while (node != null) {
+            stack.push(node)
+            node = node.left
+        }
+        // Pop the top node from the stack to process it, and decrement 'k'.
+        node = stack.pop()
+        k--
+        // If we have processed 'k' nodes, return the value of the 'k'th smallest
+        // node.
+        if (k == 0) {
+            return node.value
+        }
+        // Move to the right subtree.
+        node = node.right
+    }
+    return -1
+}

kotlin/Trees/KthSmallestNumberInBSTRecursive.kt

@@ -0,0 +1,24 @@
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int,
+        var left: TreeNode? = null,
+        var right: TreeNode? = null
+    )
+*/
+
+fun kthSmallestNumberInBSTRecursive(root: TreeNode?, k: Int): Int {
+    val sortedList = inorder(root)
+    return sortedList[k - 1]
+}
+
+// Inorder traversal function to attain a sorted list of nodes from the BST.
+fun inorder(node: TreeNode?): List<Int> {
+    if (node == null) {
+        return emptyList()
+    }
+    return inorder(node.left) + listOf(node.value) + inorder(node.right)
+}

kotlin/Trees/LowestCommonAncestor.kt

@@ -0,0 +1,40 @@
+import ds.TreeNode
+
+/*
+    Definition of TreeNode:
+
+    data class TreeNode(
+        var value: Int,
+        var left: TreeNode? = null,
+        var right: TreeNode? = null
+    )
+*/
+
+fun lowestCommonAncestor(root: TreeNode?, p: TreeNode?, q: TreeNode?): TreeNode? {
+    var lca: MutableList<TreeNode?> = mutableListOf(null)
+    dfs(root, p, q, lca)
+    return lca[0]
+}
+
+fun dfs(node: TreeNode?, p: TreeNode?, q: TreeNode?, lca: MutableList<TreeNode?>): Boolean {
+    // Base case: a null node is neither 'p' nor 'q'.
+    if (node == null) {
+        return false
+    }
+    val nodeIsPOrQ = node == p || node == q
+    // Recursively determine if the left and right subtrees contain 'p'
+    // or 'q'.
+    val leftContainsPOrQ = dfs(node.left, p, q, lca)
+    val rightContainsPOrQ = dfs(node.right, p, q, lca)
+    // If two of the above three variables are true, the current node is
+    // the LCA.
+    if ((nodeIsPOrQ && leftContainsPOrQ) ||
+                    (nodeIsPOrQ && rightContainsPOrQ) ||
+                    (leftContainsPOrQ && rightContainsPOrQ)
+    ) {
+        lca[0] = node
+    }
+
+    // Return true if the current subtree contains 'p' or 'q'.
+    return nodeIsPOrQ || leftContainsPOrQ || rightContainsPOrQ
+}