Two Ways to Explore a Tree

The plain-language idea

Picture a maze. You reach a fork with two paths. One approach: pick a path and follow it as far as it goes — around every corner, down every hallway — until you hit a dead end. Only then do you back up to the fork and try the other path. That's depth-first search: go deep before you go wide.

Now picture dropping a stone into a still pond. The ripple doesn't rush off in one direction. It spreads out evenly, in rings, all at once. That's breadth-first search: it visits everything one step away first, then everything two steps away, then three — ring by ring, level by level.

A tree — the family-tree, folder-structure kind you've already met — is a maze with no loops in it. Depth-first and breadth-first are two different orders for visiting every node in it, nothing more. Neither is more "correct" than the other. They answer different questions.

If "depth-first" or "breadth-first" sound intimidating on their own, here's the whole idea in one line each: depth-first goes deep before it goes wide, and breadth-first goes wide before it goes deep.

See it in a real thing: exploring a family tree

const familyTree = {
  name: "You",
  children: [
    { name: "Parent A", children: [{ name: "Grandparent 1", children: [] }] },
    { name: "Parent B", children: [{ name: "Grandparent 2", children: [] }] },
  ],
};

// Depth-first: follow one branch all the way down before trying the next
function depthFirst(person) {
  console.log(person.name);
  for (const child of person.children) {
    depthFirst(child); // go all the way down this branch first
  }
}

// Breadth-first: visit everyone at the current "ring" before going further out
function breadthFirst(root) {
  const queue = [root]; // people waiting to be visited, in order
  while (queue.length > 0) {
    const person = queue.shift(); // take the next person in line
    console.log(person.name);
    queue.push(...person.children); // their kids join the back of the line
  }
}

What people usually miss

Watch out

• "Which one should I use?" There isn't a universal right answer. Breadth-first is the natural choice when you want the closest match first (like the shortest chain of connections). Depth-first often uses less memory when a tree is very deep.
• Swapping a queue for a stack silently changes the traversal. Breadth-first search relies on first-in-first-out order. Swap that queue for a stack by accident, and the code quietly turns into depth-first search instead — same code shape, different result.
• You don't have to build a stack for depth-first search by hand. Writing depthFirst as a function that calls itself already uses the stack built into how function calls work. That's why the depth-first code above looks shorter than the breadth-first version.

The genealogy: recursion wearing a new hat

Depth-first search is the same self-calling-function idea from recursion in the JavaScript track, now aimed at a tree instead of a single chain of calls. Breadth-first search is new — you'll see the same queue-based pattern again soon, once trees give way to graphs.