Common Tree Problems

Written by Swapnil RajaPublished 28 Aug 2026

Nearly every tree question is post-order: solve both subtrees, then combine. Once you see that, the code stops being something you memorise.

Depth and diameter

Two answers from one traversal

javascript

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

// Longest path between any two nodes — it need not pass through the root.
function diameter(root) {
  let best = 0

  function depth(node) {
    if (!node) return 0

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

    // The best path through this node.
    best = Math.max(best, left + right)

    // What this node reports upward.
    return 1 + Math.max(left, right)
  }

  depth(root)
  return best
}

PreviousBinary Search Trees NextTries (Prefix Trees)

LCA in a general binary tree

javascript

function lca(node, a, b) {
  if (!node || node === a || node === b) return node

  const left = lca(node.left, a, b)
  const right = lca(node.right, a, b)

  // Found one on each side — this node is the meeting point.
  if (left && right) return node

  // Otherwise pass up whichever side found something.
  return left || right
}

Root to leaf

javascript

function hasPathSum(node, target) {
  if (!node) return false

  const remaining = target - node.value

  // A leaf — this is where the sum must land exactly.
  if (!node.left && !node.right) return remaining === 0

  return hasPathSum(node.left, remaining) || hasPathSum(node.right, remaining)
}

Mirror image

javascript

function isSymmetric(root) {
  if (!root) return true

  function mirror(a, b) {
    if (!a && !b) return true
    if (!a || !b) return false

    return a.value === b.value
        && mirror(a.left, b.right)   // outside pair
        && mirror(a.right, b.left)   // inside pair
  }

  return mirror(root.left, root.right)
}

Common Tree Problems

Depth and diameter

Lowest common ancestor

Path sums

Symmetry

The shape to internalise