When you start learning data structures in Kotlin, one of the most useful (and surprisingly elegant) structures you’ll come across is the binary tree. Whether you’re preparing for coding interviews, working on algorithms, or building efficient applications, Binary Trees in Kotlin are a must-have tool in your developer toolkit.

In this post, we’ll take deep dive into binary trees — starting from the basics, moving into real Kotlin code, and exploring advanced concepts. By the end, you’ll not only understand them but also know how to implement and apply them in real-world scenarios.

What Is a Binary Tree?

A binary tree is a hierarchical data structure where each node has at most two children:

• Left child
• Right child

The top node is called the root, and the last nodes with no children are called leaves.

Why use binary trees? Because they make searching, sorting, and organizing data efficient. Structures like Binary Search Trees (BST), heaps, and even syntax parsers in compilers rely on binary trees under the hood.

Defining a Binary Tree in Kotlin

Kotlin makes it easy to define data structures using classes. Let’s start simple:

// Node of a binary tree
class TreeNode<T>(val value: T) {
    var left: TreeNode<T>? = null
    var right: TreeNode<T>? = null
}

Here,

• Each node stores a value.
• It can have a left child and a right child.
• We’re using generics (<T>) so the tree can hold any type of data (Int, String, custom objects, etc.).

This flexible design means we can now create and connect nodes to form a tree.

Building a Simple Binary Tree

Let’s create a small binary tree manually:

fun main() {
    val root = TreeNode(10)
    root.left = TreeNode(5)
    root.right = TreeNode(15)

    root.left?.left = TreeNode(2)
    root.left?.right = TreeNode(7)

    println("Root: ${root.value}")
    println("Left Child: ${root.left?.value}")
    println("Right Child: ${root.right?.value}")
}

This represents the tree:

        10
       /  \
      5    15
     / \
    2   7

Run the program, and you’ll see the root and children values printed. Easy, right?

Traversing Binary Trees in Kotlin

Traversal means visiting each node in a specific order. Three main types exist:

1. Inorder (Left → Root → Right)
2. Preorder (Root → Left → Right)
3. Postorder (Left → Right → Root)

Here’s how we can implement them in Kotlin:

fun inorder(node: TreeNode<Int>?) {
    if (node != null) {
        inorder(node.left)
        print("${node.value} ")
        inorder(node.right)
    }
}

fun preorder(node: TreeNode<Int>?) {
    if (node != null) {
        print("${node.value} ")
        preorder(node.left)
        preorder(node.right)
    }
}

fun postorder(node: TreeNode<Int>?) {
    if (node != null) {
        postorder(node.left)
        postorder(node.right)
        print("${node.value} ")
    }
}

• Inorder traversal (for a Binary Search Tree) gives sorted output.
• Preorder is useful for copying or serializing the tree.
• Postorder is used in deleting trees safely or evaluating expressions.

Binary Search Tree (BST) in Kotlin

A Binary Search Tree is a special type of binary tree where:

• Left child values are smaller than the parent.
• Right child values are greater than the parent.

Here’s a simple insert function:

fun insert(node: TreeNode<Int>?, value: Int): TreeNode<Int> {
    if (node == null) return TreeNode(value)

    if (value < node.value) {
        node.left = insert(node.left, value)
    } else if (value > node.value) {
        node.right = insert(node.right, value)
    }

    return node
}

Usage:

fun main() {
    var root: TreeNode<Int>? = null
    val values = listOf(10, 5, 15, 2, 7)

    for (v in values) {
        root = insert(root, v)
    }

    println("Inorder Traversal (sorted):")
    inorder(root)
}

This builds the same tree as before, but dynamically by inserting values.

Advanced: Balancing and Height of Trees

Binary trees can get skewed if values are inserted in sorted order. For example, inserting 1, 2, 3, 4, 5 creates a “linked list” shaped tree, which defeats the efficiency.

That’s where balanced trees (like AVL Trees or Red-Black Trees) come into play. While implementing them from scratch is complex, so, understanding the height of a tree is the first step:

fun height(node: TreeNode<Int>?): Int {
    if (node == null) return 0
    return 1 + maxOf(height(node.left), height(node.right))
}

Height helps us measure balance:

• In an AVL Tree, the heights of the left and right subtrees of any node can differ by at most 1.
• In a Red-Black Tree, balance is maintained using color properties and black-height rules.

Thus, height is foundational for understanding balance, though balanced trees enforce it using additional rules and (sometimes) rotations.

Real-World Applications of Binary Trees

Binary trees aren’t just academic exercises. They’re used in:

• Databases (indexing and searching)
• Compilers (syntax parsing using expression trees)
• Games (AI decision-making with decision trees)
• Networking (routing tables)

So, mastering binary trees in Kotlin gives you both practical coding skills and deeper algorithmic insight.

Conclusion

Binary trees may look intimidating at first, but with Kotlin’s clean syntax and strong type system, they become intuitive and fun to implement. From simple trees to Binary Search Trees and beyond, you now have a solid foundation.

Next time you see a coding challenge or need to optimize a search algorithm, you’ll know exactly how to leverage Binary Trees in Kotlin.