Trees: Literally a Family Tree

The plain-language idea

You've probably seen a family tree before — maybe drawn on a poster board, maybe sketched on paper. One person sits at the top. Lines drop down from them to their children. Lines drop down from each of those children to their own children. The whole shape branches downward, wider at the bottom than at the top.

A tree, in code, is exactly that shape, holding any kind of data instead of family members. One item sits at the top. It connects downward to a few items below it. Each of those connects downward to a few more. Nothing loops back up — everything flows in one direction, top to bottom, just like a family tree never has your grandchild also be your grandparent.

Because you already know how to read a family tree, you already know most of the vocabulary trees use in code. It's worth learning these words on purpose, because they show up constantly once you start reading about trees:

• Root — the person at the very top, with no one above them. In a tree, it's the single starting item everything else branches from.
• Parent — anyone with people branching below them. If box A connects down to box B, A is B's parent.
• Child — anyone branching below a parent. B, from that same example, is A's child.
• Leaf — someone at the very bottom of a branch, with no children of their own. In a family tree, that's the youngest generation you've drawn; in a tree, it's any node with nothing below it.

See it in a real thing: a tiny family tree in code

// Each person is a node: a name, and a list of their children (also nodes).
function makePerson(name, children = []) {
  return { name, children };
}

// Build from the bottom up, then attach children to their parent.
const grandchild1 = makePerson("Mia");
const grandchild2 = makePerson("Leo");
const child = makePerson("Sam", [grandchild1, grandchild2]); // Sam is the parent here
const root = makePerson("Ana", [child]); // Ana is the root — nobody above her

// Print the whole family, indenting each generation to show depth.
function printFamily(person, depth = 0) {
  console.log("  ".repeat(depth) + person.name);
  for (const kid of person.children) {
    printFamily(kid, depth + 1); // walk down into each child
  }
}

printFamily(root);
// Ana
//   Sam
//     Mia
//     Leo

Mia and Leo are leaves here — the code never finds any children for them, because their children array is empty by default.

What people usually miss

Watch out

• Expecting a child to have more than one parent. In the trees used in most interview questions, each child has exactly one parent above it — no sharing. If something needs multiple parents, it's usually a different shape entirely, called a graph, which is a topic for later.
• Confusing "leaf" with "bottom of the whole tree." A leaf just means "this specific node has no children" — different branches can have leaves at different depths, the same way one branch of a real family might have great-grandchildren while another stops at grandchildren.
• Thinking a tree always needs exactly 2 children per node. A general tree, like the family tree above, can have any number of children per parent. A tree where every node has at most 2 children is its own specific, important shape, and it's coming up next.

The genealogy: the same idea you build on

Family trees already showed you the words "root," "parent," and "child" long before any code did. Everything you learn about trees from here — including the special two-children-max version coming up next — is this exact same branching shape, with one extra rule layered on top.