Binary Trees: Structure, Traversal, and Operations

This reading introduces the definition, terminology (root, parent, child, leaf), and structural rules of binary trees, giving learners the conceptual foundation needed before studying algorithms or specialized tree variants.

This reading explains the anatomy of a binary tree at the node level — covering pointer structure, left/right child relationships, and how nodes link together — so learners can reason precisely about tree construction and manipulation.

This reading defines the Binary Search Tree ordering property (left subtree holds smaller values, right holds larger), distinguishing BSTs from general binary trees, so learners understand the invariant that makes BST operations efficient.

This reading walks through how insertion and search operations work in a BST by following the ordering invariant at each node, helping learners understand the recursive logic and efficiency of these two core operations.

This reading covers the three cases of BST node deletion — leaf node, one-child node, and two-child node (using in-order successor/predecessor) — so learners understand how to remove nodes without violating the BST ordering property.

This reading surveys tree traversal strategies — including in-order, pre-order, post-order, and level-order — explaining the visit sequence each produces and when each strategy is appropriate for a given task.

This reading guides learners through a complete from-scratch JavaScript implementation of a BST, including class and node structure and recursive algorithms, so they can translate conceptual BST knowledge into working code.

A readed lesson introducing binary trees as hierarchical node-and-edge structures with at most two children per node, contrasting their branching layout with linear arrays and linked lists so learners understand why trees suit searching and organizing data.

A reading that establishes the vocabulary of tree anatomy — nodes holding a key plus left and right child references, null links, leaves, parents, depth and height — giving learners the terminology needed before studying traversal and search.

A conceptual reading on binary search trees that explains the ordering property (left subtree smaller, right subtree larger) and shows how this single rule enables efficient lookups that an unordered binary tree cannot support.

A lesson walking through BST insertion and search, showing how both operations start at the root and compare keys to decide whether to move left or right while preserving the ordering property.

A reading on BST deletion that breaks the operation into the three standard cases — removing a node with zero, one, or two children — and explains how to repair the tree afterward, including the successor/predecessor replacement technique.

A lesson on systematically visiting every node exactly once, comparing the depth-first in-order, pre-order, and post-order rules (and their differing output orders) so learners can pick the right traversal for a given task.

A hands-on coding topic that translates BST theory into JavaScript, guiding learners to build a Node class and a BinarySearchTree class and to add insertion, search, and traversal methods one at a time.

A consolidated reading that compiles all module topics — tree fundamentals, node anatomy, BST concepts, insertion, search, deletion, traversal, and JavaScript implementation — into a single document for review or offline study.

This reading guides learners through a complete from-scratch JavaScript implementation of a BST, including class and node structure and recursive algorithms, so they can translate conceptual BST knowledge into working code.

An interactive browser-based game in which learners build the binary expression tree for a given PEMDAS arithmetic equation (e.g., (7-2)*(3+4)) and then traverse it to produce prefix, infix, or postfix output, used as hands-on practice connecting expression trees to traversal orders.

Expression Arbor is a browser-based interactive exercise in which students build a binary expression tree from a given arithmetic expression by placing operator and operand tiles onto a growing tree structure. As the tree takes shape, the activity displays the resulting pre-order, in-order, and post-order 'walks' and scores each attempt against the correct traversal sequences. Color coding distinguishes operators, numbers, and parentheses, and a round map tracks progress, correctness, and points across multiple expression challenges.