Binary Trees 101: Building, Traversing, and Searching

If you’ve spent any time around computer science, you’ve probably heard the term binary tree. They pop up everywhere—databases, file systems, even machine learning models. But what exactly are they, and why do developers love them so much?

In this post, we’ll break down binary trees in plain language, explore their key features, and walk through some real-world examples (with PHP and JavaScript code you can try out yourself).

What is a Binary Tree?

At its core, a binary tree is just a way of organizing data. Imagine a family tree: you’ve got a root node at the top, and each node can branch out to two “children”—a left and a right. That’s why it’s called binary (two branches).

If a node doesn’t have a child in one direction, that side is just null. Pretty simple!

Why Use Binary Trees?

Binary trees aren’t just for fun—they’re powerful because of what they let us do:

Organize data hierarchically – Parent-child relationships make it easy to structure things like file systems or categories.
Search efficiently – Instead of scanning through everything, you can “zoom in” by going left or right at each step (like playing 20 Questions with your data).
Fast insertion & deletion – You can add or remove items without too much hassle, often in O(log n) time.
Stay balanced – Variants like AVL trees or Red-Black trees keep both sides of the tree roughly equal, preventing your tree from turning into a sad, lopsided list.

Common Operations on Binary Trees

Here’s where binary trees get interesting. You can do a lot with them:

1. Traversal

Traversal just means “visiting every node in a certain order.” Common ones are:

In-order (Left → Root → Right): Produces sorted output in a binary search tree.
Pre-order (Root → Left → Right): Great for copying a tree.
Post-order (Left → Right → Root): Handy for deleting a tree.

2. Search

Looking for a value? Compare it to the current node. If it’s smaller, go left. If it’s bigger, go right. Repeat until you find it (or hit null).

3. Insertion

Same logic as search, except when you find a null spot, you plug in your new node there.

4. Deletion

A little trickier:

No children? Just remove it.
One child? Replace the node with its child.
Two children? Find the smallest value in the right subtree (or largest in the left) and swap it in.

Variations of Binary Trees

Not all binary trees are created equal. Some special ones include:

Full Binary Tree: Every node has 0 or 2 children.
Complete Binary Tree: All levels filled (except maybe the last), and nodes are packed to the left.
Balanced Binary Tree: Keeps the height as small as possible, so searches stay fast.

Real-World Applications

Binary trees aren’t just academic exercises—they power a lot of systems you use every day:

Database indexing (B-trees, B+ trees).
File systems, where directories branch into files and subdirectories.
Decision trees in machine learning.
Expression evaluation, like parsing math formulas into a tree.

Let’s Code One

Here’s a quick look at binary tree basics in PHP and JavaScript.

Defining a Node

class TreeNode {
    public $value;
    public $left;
    public $right;

    public function __construct($value) {
        $this->value = $value;
        $this->left = null;
        $this->right = null;
    }
}

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

Inserting a Node (Binary Search Tree style)

class BinaryTree {
    public $root = null;

    public function insert($value) {
        $this->root = $this->insertRec($this->root, $value);
    }

    private function insertRec($node, $value) {
        if ($node === null) return new TreeNode($value);
        if ($value < $node->value) {
            $node->left = $this->insertRec($node->left, $value);
        } else {
            $node->right = $this->insertRec($node->right, $value);
        }
        return $node;
    }
}

class BinaryTree {
    constructor() {
        this.root = null;
    }

    insert(value) {
        this.root = this.insertRec(this.root, value);
    }

    insertRec(node, value) {
        if (node === null) return new TreeNode(value);
        if (value < node.value) {
            node.left = this.insertRec(node.left, value);
        } else {
            node.right = this.insertRec(node.right, value);
        }
        return node;
    }
}

Traversing (In-Order)

public function inOrderTraversal($node) {
    if ($node !== null) {
        $this->inOrderTraversal($node->left);
        echo $node->value . " ";
        $this->inOrderTraversal($node->right);
    }
}

inOrderTraversal(node) {
    if (node !== null) {
        this.inOrderTraversal(node.left);
        console.log(node.value);
        this.inOrderTraversal(node.right);
    }
}

Wrapping Up

Binary trees are one of those “aha!” data structures—once you get them, you start noticing them everywhere. They’re efficient, elegant, and surprisingly practical in real-world applications.

By learning how to build, traverse, search, insert, and delete nodes, you’ve covered the foundations. From there, you can explore more advanced variants like AVL trees, Red-Black trees, or even dive into decision trees for machine learning.

Mastering binary trees isn’t just about passing algorithms class—it’s about leveling up as a developer who can choose the right tool for the job.

Missing Parenthesis