Binary Search Trees: A Family Tree With a Rule

The plain-language idea

You now know two things separately: the guess-the-number game, where guessing the middle cuts your remaining options in half each time, and the family tree shape, where one item branches down into children. A binary search tree puts those two ideas together.

Picture the same family-tree shape from the last lesson, but with a strict house rule at every single branch: anything smaller than this node goes in the left branch, anything bigger goes in the right branch. Every node, all the way down, follows that same rule — not just the root.

Here's why that rule matters. If you're searching for a value and you're standing at a node, the rule tells you exactly which way to go, immediately. Looking for something smaller than the current node? Go left — there's no reason to ever check the right side, because the rule guarantees nothing you want lives there. That's the guess-the-number halving trick again, except now it's built into the shape of the tree itself instead of you doing the halving with your own math.

Also worth naming directly, because it trips people up: "binary" here means "at most 2 children per node" — not "made of 1s and 0s." Every node has room for a left child and a right child, and that's the maximum. A regular tree, from the last lesson, could have any number of children; a binary tree is the specific, stricter version with a cap of 2.

See it in a real thing: building and searching a small BST

// Each node: a value, a left child (smaller), and a right child (bigger).
function makeNode(value, left = null, right = null) {
  return { value, left, right };
}

// A small binary search tree, built by hand to show the rule in action.
//        8
//       / \
//      3   10
//       \
//        6
const tree = makeNode(8,
  makeNode(3, null, makeNode(6)),
  makeNode(10)
);

function search(node, target) {
  if (node === null) return false;       // fell off the tree — not found
  if (node.value === target) return true; // found it

  // The rule: smaller goes left, bigger goes right.
  if (target < node.value) {
    return search(node.left, target);
  } else {
    return search(node.right, target);
  }
}

console.log(search(tree, 6));  // true  — 8 -> 3 -> 6
console.log(search(tree, 5));  // false — 8 -> 3 -> (nothing there)

Trace the search for 6: start at 8. 6 < 8, go left to 3. 6 > 3, go right to 6. Found it — 2 steps, without ever glancing at the 10 branch, because the rule already ruled it out.

What people usually miss

Watch out

• Thinking the rule only applies at the root. It applies at every single node, all the way down. A node's entire left branch must be smaller than it, and its entire right branch must be bigger than it — not just its immediate children.
• Assuming every binary tree is a binary search tree. "At most 2 children" is the binary tree rule. "Smaller left, bigger right, everywhere" is the extra binary search tree rule stacked on top. All binary search trees are binary trees, but not the other way around.
• Forgetting what a lopsided tree does to speed. If values are inserted in already-sorted order, the tree can end up as one long line leaning entirely to one side, with no real branching. The halving trick depends on the tree being reasonably balanced — a badly shaped one loses the speed advantage entirely.

The genealogy: binary search, wearing a tree shape

This lesson is where two earlier ideas in this track meet. The halving instinct from the guess-the-number game is still doing the work — every step down a binary search tree throws away one whole branch, the same way every guess in that game threw away half the numbers. What changed is the container: instead of guessing the middle of a sorted list yourself, the tree shape from the family-tree lesson encodes that middle-guessing rule directly into its structure, so following the rule at each node does the halving for you.