Binary Tree Implementation in Kotlin

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

1. Introduction

In this tutorial, we will learn how to implement a simple Binary Tree data structure using Kotlin programming language.

A Binary Tree is a tree data structure in which each node has at most two children, typically referred to as the left child and the right child. It is one of the most commonly used data structures due to its efficiency in various operations like insertion, deletion, and search.

2. Implementation Steps

1. Define a Node class to represent individual nodes in the binary tree.

2. Create a BinaryTree class that will provide methods for common operations.

3. Implement methods such as insert, search, delete, preOrderTraversal, inOrderTraversal, and postOrderTraversal.

3. Implementation in Kotlin Programming

// Define the Node class
class Node(val data: Int) {
    var left: Node? = null
    var right: Node? = null
}

class BinaryTree {
    var root: Node? = null
    
    // Insert data into the binary tree
    fun insert(value: Int) {
        root = insertRecursive(root, value)
    }
    
    private fun insertRecursive(current: Node?, value: Int): Node {
        if (current == null) {
            return Node(value)
        }
        if (value < current.data) {
            current.left = insertRecursive(current.left, value)
        } else if (value > current.data) {
            current.right = insertRecursive(current.right, value)
        }
        return current
    }
    
    // Search for a value in the tree
    fun search(value: Int): Boolean {
        return searchRecursive(root, value)
    }
    
    private fun searchRecursive(current: Node?, value: Int): Boolean {
        if (current == null) {
            return false
        }
        if (value == current.data) {
            return true
        }
        return if (value < current.data) {
            searchRecursive(current.left, value)
        } else {
            searchRecursive(current.right, value)
        }
    }
    
    // Delete a value from the tree
    fun delete(value: Int) {
        root = deleteRecursive(root, value)
    }
    
    private fun deleteRecursive(current: Node?, value: Int): Node? {
        if (current == null) {
            return null
        }
        if (value == current.data) {
            if (current.left == null && current.right == null) {
                return null
            }
            if (current.right == null) {
                return current.left
            }
            if (current.left == null) {
                return current.right
            }
            val smallestValue = findSmallestValue(current.right!!)
            current.data = smallestValue
            current.right = deleteRecursive(current.right, smallestValue)
            return current
        }
        if (value < current.data) {
            current.left = deleteRecursive(current.left, value)
            return current
        }
        current.right = deleteRecursive(current.right, value)
        return current
    }
    
    private fun findSmallestValue(root: Node): Int {
        return if (root.left == null) {
            root.data
        } else {
            findSmallestValue(root.left!!)
        }
    }
    
    // Different tree traversal methods
    fun preOrderTraversal(node: Node?) {
        if (node != null) {
            println(node.data)
            preOrderTraversal(node.left)
            preOrderTraversal(node.right)
        }
    }
    
    fun inOrderTraversal(node: Node?) {
        if (node != null) {
            inOrderTraversal(node.left)
            println(node.data)
            inOrderTraversal(node.right)
        }
    }
    
    fun postOrderTraversal(node: Node?) {
        if (node != null) {
            postOrderTraversal(node.left)
            postOrderTraversal(node.right)
            println(node.data)
        }
    }
}

// Client code
fun main() {
    val tree = BinaryTree()
    tree.insert(6)
    tree.insert(4)
    tree.insert(8)
    tree.insert(3)
    tree.insert(5)
    tree.insert(7)
    tree.insert(9)
    println("Pre-order traversal:")
    tree.preOrderTraversal(tree.root)
    println("\nIn-order traversal:")
    tree.inOrderTraversal(tree.root)
    println("\nPost-order traversal:")
    tree.postOrderTraversal(tree.root)
    println("\nSearch for 5: ${tree.search(5)}")
    println("Search for 10: ${tree.search(10)}")
    tree.delete(5)
    println("\nIn-order traversal after deleting 5:")
    tree.inOrderTraversal(tree.root)
}

Output:

Pre-order traversal:
6
4
3
5
8
7
9
In-order traversal:
3
4
5
6
7
8
9
Post-order traversal:
3
5
4
7
9
8
6
Search for 5: true
Search for 10: false
In-order traversal after deleting 5:
3
4
6
7
8
9

Explanation:

1. The Node class represents each individual node in the Binary Tree, containing data, left, and right attributes.

2. The BinaryTree class contains various operations like insert, search, and delete.

3. The insert operation adds a new node to the tree in its correct position based on the node's value.

4. The search operation checks if a value exists in the tree and returns a boolean.

5. The delete operation removes a node from the tree. If the node to be deleted is a leaf node, it's straightforward. If the node has one child, that child replaces the node. If the node has two children, the node's right child's leftmost node replaces the deleted node.

6. The preOrderTraversal, inOrderTraversal, and postOrderTraversal methods are tree traversal operations that visit nodes in different orders.

7. The client code showcases the various methods in action and their outputs.