COURSE: DATA STRUCTURES & ALGORITHMS
SECTION 06 // BINARY SEARCH TREES
C++ DATA STRUCTURES•SPRING
Section 6 — Data Structures
Binary Search Trees
From the shape of a binary tree to the ordering rule that makes it searchable — then one node type and seven routines: three depth-first traversals, a node count, insertion and search.
WHAT WE'LL COVER11 SLIDES
- 01Cover
- 02Binary Tree
- 03Binary Search Tree
- 04Tree Terminology
- 05Node Structure
- 06Pre-order Traversal
- 07In-order Traversal
- 08Post-order Traversal
- 09Node Count
- 10BST Insertion
- 11BST Search
C++ · Binary Search Tree · Traversals · Recursion
SECTION 06: FOUNDATIONS
SLIDE 02 // BINARY TREE
AT MOST TWO CHILDREN
Foundations
What is a Binary Tree?
A tree where every node holds at most two children — a left and a right — and exactly one path leads from the root to each node.
CHILDRENWHAT THE NODE LOOKS LIKE
2Both pointers in use: a left subtree and a right subtree.
1One child on one side; the other pointer is
nullptr.0A leaf:
left and right are both empty.ARITYat most two children per node — never three.
PATHone route from the root down to any node.
EMPTYno nodes at all still counts as a tree.
NO CYCLESEach node has exactly one parent, so a walk from the root cannot come back to where it started — that is what separates a tree from a graph.
A BINARY TREEEVERY NODE ≤ 2 CHILDREN
50
30
70
20
40
60
80
NOT A BINARY TREETHREE CHILDREN
50
30
70
90
third childBinary means at most two: 50 would need three pointers to hold 30, 70 and 90, and the struct only has left and right.
SECTION 06: FOUNDATIONS
SLIDE 03 // BINARY SEARCH TREE
LEFT < NODE < RIGHT
Foundations
What is a Binary Search Tree?
A binary tree with one extra promise: everything left of a node is smaller, everything right of it is larger — at every node, not just the root.
WHERETHE RULE
leftEvery value in the whole left subtree is smaller than the node.
rightEvery value in the whole right subtree is larger than the node.
every nodeThe promise is checked at each node on the way down, not once at the root.
equalA duplicate key is either rejected or counted — this program rejects it.
WHY IT MATTERSBecause of the order, a search can throw away one whole subtree per comparison — so the cost is the height, not the number of nodes.
THE ORDERING RULELEFT < NODE < RIGHT
50
30
70
20
40
60
80
every value < 50every value > 50The rule is checked at every node: 60 is right of 50 but left of 70, and both promises hold at the same time.
ORDER BROKENBINARY, NOT A BST
50
60
70
60 > 50Binary, yes — searchable, no. 60 sits on 50's left, yet a search for it would compare 60 > 50 and turn right.
SECTION 06: FOUNDATIONS
SLIDE 04 // TREE TERMINOLOGY
ROOT · LEAF · SUBTREE
Vocabulary
Tree Terminology
Six words that every later slide depends on — all of them pointing at the same seven-node tree.
TERMWHAT IT MEANS
rootThe one node with no parent — 50 here.
leafA node with no children: 20, 40, 60, 80.
parent / childOne level apart, joined by an edge: 30 is the parent of 20 and 40.
siblingTwo nodes with the same parent: 20 and 40.
subtreeA node plus everything below it: 70 with 60 and 80.
levelSteps down from the root: 0 for 50, 1 for 30 and 70, 2 for the leaves.
HEIGHT COUNTS EDGESA level counts the nodes above you; height counts the edges down to the deepest leaf. This tree is level 2 and height 2.
THE SAME TREE, NAMEDROOT · LEVEL · SUBTREE
50
30
70
20
40
60
80
rootL0L1L2subtreeLeaves: 20, 40, 60, 80 · siblings: 20 and 40 · 30 is their parent · height 2, size 7.
SIZE = 7Seven nodes: one root, two children, four leaves — and each of them is itself a subtree of the whole.
SECTION 06: FOUNDATIONS
SLIDE 05 // NODE STRUCTURE
data•left•right
The Building Block
Node Structure
One value and two pointers. data carries the key, left and right point at the two subtrees — or at nothing at all.
MEMBERROLETYPE
dataThe value stored in the node.
intleftAddress of the left subtree.
Node*rightAddress of the right subtree.
Node*Node(value)Constructor: stores the value, both children start empty.
NodeSELF-REFERENTIALleft and right are
Node* — the struct points at its own type, which is what lets a node hold a subtree.ONE NODE — THREE FIELDSPAYLOAD + TWO POINTERS
left — Node*•data — int50right — Node*•
AT CREATIONNode(50)
MEMBERVALUEMEANING
data50the key this node holdsleftnullptrno left subtree yetrightnullptrno right subtree yetNODE.CPPC++ STRUCT
struct Node { int data; Node* left; Node* right; // Constructor Node(int value) { data = value; left = nullptr; right = nullptr; }};
SECTION 06: TRAVERSALS
SLIDE 06 // PRE-ORDER TRAVERSAL
ROOT → LEFT → RIGHT
Traversals
Pre-order: Root First
Print the node the moment you reach it, then recurse into its left subtree, then its right.
PHASEWHAT COMES OUT
1 · print
50 — the node itself, before anything below it.2 · left
30 20 40 — the whole left subtree, same rule again.3 · right
70 60 80 — the whole right subtree, last.PREORDER.CPPC++ FUNCTION
void printPreorder(Node* root) { if (root != nullptr) { cout << root->data << " "; printPreorder(root->left); printPreorder(root->right); }}
VISIT ORDER1 → 7
501
302
705
203
404
606
807
CONSOLE OUTPUTPRE-ORDER
Pre-order: 50 30 20 40 70 60 80
ROOT FIRSTThe print sits above both recursive calls, so a parent is always written before any of its children.
SECTION 06: TRAVERSALS
SLIDE 07 // IN-ORDER TRAVERSAL
LEFT → ROOT → RIGHT
Traversals
In-order: Smallest First
Take the whole left subtree first, then print the node, then take the right. In a search tree that walks the keys in ascending order.
PHASEWHAT COMES OUT
1 · left
20 30 40 — everything smaller than the node, already sorted.2 · print
50 — the node, once its left side is spent.3 · right
60 70 80 — the larger keys, last.INORDER.CPPC++ FUNCTION
void printInorder(Node* root) { if (root != nullptr) { printInorder(root->left); cout << root->data << " "; printInorder(root->right); }}
VISIT ORDER1 → 7
504
302
706
201
403
605
807
CONSOLE OUTPUTIN-ORDER
In-order (Sorted): 20 30 40 50 60 70 80
SORTEDEvery key in the left subtree is smaller and every key on the right is larger, so left → node → right can only come out ascending.
SECTION 06: TRAVERSALS
SLIDE 08 // POST-ORDER TRAVERSAL
LEFT → RIGHT → ROOT
Traversals
Post-order: Children First
Both subtrees first, the node last. Nothing is printed until everything beneath it has already been printed.
PHASEWHAT COMES OUT
1 · left
20 40 30 — the left subtree, itself walked children-first.2 · right
60 80 70 — the right subtree, same rule again.3 · print
50 — the node, only once both sides are spent.POSTORDER.CPPC++ FUNCTION
void printPostorder(Node* root) { if (root != nullptr) { printPostorder(root->left); printPostorder(root->right); cout << root->data << " "; }}
VISIT ORDER1 → 7
507
303
706
201
402
604
805
CONSOLE OUTPUTPOST-ORDER
Post-order: 20 40 30 60 80 70 50
ROOT LASTThe print sits below both recursive calls, so a node is written only after every node under it — the root always comes out last.
SECTION 06: RECURSION
SLIDE 09 // NODE COUNT
1 + SIZE(LEFT) + SIZE(RIGHT)
Divide & Conquer
Node Count: One Plus Two
The size of a tree is one — for the node itself — plus the size of its left subtree and the size of its right subtree. The same question, asked of two smaller trees.
CASEWHAT IT RETURNS
empty
0 — the one case that needs no recursion.the node
1 — every node counts itself first.subtrees
+ left + right — both answers come back before the sum.NODECOUNT.CPPC++ FUNCTION
int nodeCount(Node* root) { if (root == nullptr) return 0; return 1 + nodeCount(root->left) + nodeCount(root->right);}
SUBTREE SIZESBOTTOM-UP
507
303
703
201
401
601
801
CONSOLE OUTPUTNODE COUNT
Total Node Count: 7
BOTTOM-UPNothing is counted on the way down: the leaves return 1, and every parent returns 1 plus the two numbers it was handed.
SECTION 06: OPERATIONS
SLIDE 10 // BST INSERTION
COMPARE · TURN · ATTACH
Insertion
Insert: Follow the Comparisons
Compare, turn, repeat: the first empty pointer the walk reaches is the slot.
SMALLERGo left — smaller keys live in the left subtree.
LARGERGo right — larger keys live in the right subtree.
NULLPTRThis empty pointer is the slot: create the node and return it.
INSERT.CPPC++ FUNCTION
Node* insert(Node* root, int value) { if (root == nullptr) { return new Node(value); } if (value < root->data) { root->left = insert(root->left, value); } else if (value > root->data) { root->right = insert(root->right, value); } // If value == root->data, we ignore it (BST assumes unique values) return root;}
WHERE 80 LANDS50 → 70 → RIGHT
50
30
70
20
40
60
80
COMPARISON PATHINSERT 80
50 → 70 → nullptr → Node(80)
ONE POINTEROnly the empty pointer the walk stopped at changes. Every ancestor keeps its value and its other child, and hands the same root back up.
SECTION 06: OPERATIONS
SLIDE 11 // BST SEARCH
EQUAL · LEFT · RIGHT
Searching
Search: Halve, Then Halve Again
Equal means found; smaller goes left, larger goes right; nullptr means absent.
EQUALreturn true — the key sits at this node.
SMALLERcurrent = current->left
LARGERcurrent = current->right
SEARCH.CPPC++ FUNCTION
bool search(Node* root, int key) { Node* current = root; while (current != nullptr) { if (key == current->data) { return true; // Value found } else if (key < current->data) { current = current->left; // Search left subtree } else { current = current->right; // Search right subtree } } return false; // Value not found}
SEARCH 40 — FOUND50 → 30 → 40
50
30
70
20
40
60
80
CONSOLE OUTPUTBST SEARCH
Value 40 found in the tree.
Value 90 NOT found.
Value 90 NOT found.
A MISS90 is larger than 50, larger than 70, larger than 80 — and 80 is a leaf, so the walk ends on nullptr.