Binary Trees Explained

Written by Swapnil RajaPublished 28 Aug 2026

A tree is the first structure where recursion stops being a technique and becomes the natural way to think. A tree is a node with two smaller trees hanging off it - that sentence is the whole subject.

The structure

A node, and a tree

javascript

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

//       1
//      / \
//     2   3
//    / \
//   4   5
const root = new TreeNode(1,
  new TreeNode(2, new TreeNode(4), new TreeNode(5)),
  new TreeNode(3)
)

PreviousHeap Sort and Streaming Data NextBinary Search Trees

Pre, in, and post order

javascript

// From the Binary Trees lesson, repeated so this example runs on its own.
class TreeNode {
  constructor(value, left = null, right = null) {
    this.value = value
    this.left = left
    this.right = right
  }
}

const root = new TreeNode(1,
  new TreeNode(2, new TreeNode(4), new TreeNode(5)),
  new TreeNode(3)
)

// Pre-order: node, left, right. Use to copy a tree.
function preOrder(node, out = []) {
  if (!node) return out
  out.push(node.value)
  preOrder(node.left, out)
  preOrder(node.right, out)
  return out
}

// In-order: left, node, right. On a BST this gives sorted output.
function inOrder(node, out = []) {
  if (!node) return out
  inOrder(node.left, out)
  out.push(node.value)
  inOrder(node.right, out)
  return out
}

// Post-order: left, right, node. Use to delete, or to size up.
function postOrder(node, out = []) {
  if (!node) return out
  postOrder(node.left, out)
  postOrder(node.right, out)
  out.push(node.value)
  return out
}

console.log(preOrder(root))   // [1, 2, 4, 5, 3]
console.log(inOrder(root))    // [4, 2, 5, 1, 3]
console.log(postOrder(root))  // [4, 5, 2, 3, 1]

Level order

javascript

// From the Binary Trees lesson, repeated so this example runs on its own.
class TreeNode {
  constructor(value, left = null, right = null) {
    this.value = value
    this.left = left
    this.right = right
  }
}

const root = new TreeNode(1,
  new TreeNode(2, new TreeNode(4), new TreeNode(5)),
  new TreeNode(3)
)

function levelOrder(root) {
  if (!root) return []

  const out = []
  const queue = [root]
  let head = 0

  while (head < queue.length) {
    const levelSize = queue.length - head
    const level = []

    for (let i = 0; i < levelSize; i++) {
      const node = queue[head++]
      level.push(node.value)
      if (node.left) queue.push(node.left)
      if (node.right) queue.push(node.right)
    }

    out.push(level)
  }

  return out
}

console.log(levelOrder(root))  // [[1], [2, 3], [4, 5]]

The template

javascript

function solve(node) {
  if (!node) return /* the answer for nothing */

  const left = solve(node.left)
  const right = solve(node.right)

  return /* combine left, right and node.value */
}

function height(node) {
  if (!node) return 0
  return 1 + Math.max(height(node.left), height(node.right))
}

Binary Trees Explained

The structure

Three depth-first orders

Level order, breadth first

The recursive shape