Mohammed Shaikh

Posted on Dec 20

Trees Fundamentals: Structure, Terminology, and Use Cases

#algorithms #javascript #programming #learning

This post introduces Trees, one of the most common and important data structures in computer science. Trees show up everywhere — in file systems, the DOM, compilers, databases, operating systems, pathfinding, and tons of interview questions.

This is Part 1.1 of the Data Structures Series.

What Is a Tree?

A Tree is a hierarchical, non-linear data structure made of nodes.

Each node:

Stores a value
Has zero or more children
Has exactly one parent (except the root)

Common real-world analogies:

Folder structures
Company org charts
Website DOM

Trees are ideal when the data naturally forms a hierarchy.

Common Types of Trees

There are many variations of trees, but these are the ones most used in software and interviews:

Binary Tree
Binary Search Tree (BST)
AVL Tree
Red-Black Tree
N-ary Tree
Trie (Prefix Tree)

This post focuses on the Binary Tree, since most traversal logic starts here.

What Is a Binary Tree?

A Binary Tree is a tree where each node has at most two children.

Let's create one in JavaScript:

class Node {
  constructor(key, left = null, right = null) {
    this.left = left;
    this.right = right;
    this.val = key;
  }
}

const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

// The tree structure:
//        1
//       / \
//      2   3
//     / \
//    4   5

You can also build the tree with nested constructor calls, but this form is more readable for beginners.

Tree Traversals

Traversals describe how we "walk" through a tree. There are four fundamental traversal patterns:

Inorder
Preorder
Postorder
Breadth-First Search (Level Order)

We'll go deeper into each in Part 1.2, but here is a quick preview.

Inorder (Left → Root → Right)

Useful in Binary Search Trees because it returns nodes in sorted order.

function inorderTraversal(node) {
  if (node !== null) {
    inorderTraversal(node.left);
    console.log(node.val);
    inorderTraversal(node.right);
  }
}

Preorder (Root → Left → Right)

Good for serializing or copying trees.

function preorderTraversal(node) {
  if (node !== null) {
    console.log(node.val);
    preorderTraversal(node.left);
    preorderTraversal(node.right);
  }
}

Postorder (Left → Right → Root)

Commonly used when deleting or evaluating trees.

function postorderTraversal(node) {
  if (node !== null) {
    postorderTraversal(node.left);
    postorderTraversal(node.right);
    console.log(node.val);
  }
}

Breadth-First Search (Level Order)

Visits each level of the tree from left to right.

function breadthFirstTraversal(root) {
  const queue = [root];

  while (queue.length > 0) {
    const currentNode = queue.shift();
    console.log(currentNode.val);

    if (currentNode.left) queue.push(currentNode.left);
    if (currentNode.right) queue.push(currentNode.right);
  }
}

Why Traversals Matter

Different problems require different traversal strategies:

Inorder → sorted output in BSTs
Preorder → reconstructing or serializing trees
Postorder → evaluating expressions, deleting structures
BFS → shortest path, level-by-level processing

You'll see these patterns repeatedly in interviews.

Continue the Data Structures Series

This post is part of an ongoing Data Structures Series focused on clarity, real-world intuition, and JavaScript implementations.

View the full roadmap:

DEV Community