Data Structures & Algorithms

Pre-Midterm Revision

Six sections, one pass. Recall the rules, predict an output, repair broken code, watch the structure move, then write it yourself.

Arrays · Linked Lists · Recursion · Stacks · Queues · BST

Section 1 · Arrays

Five Ideas, One Screen

Five ideas to have ready before the questions start. No new material — just the array rules the exam expects you to recall instantly.

IDEAREMEMBER

ArrayA fixed-size block of same-type elements stored contiguously.

1DOne index: arr[i] — a single row of cells.

2DTwo indexes: arr[row][col] — a table of rows and columns.

Zero-basedThe first cell is index 0; the last is n - 1.

AccessRead arr[i]; modify with arr[i] = value.

Traversefor (int i = 0; i < n; i++) visits every cell once.

ONE DIMENSION · int arr[5]

010arr[0]

120arr[1]

230arr[2]

340arr[3]

450arr[4]

TWO DIMENSIONSROW FIRST, THEN COLUMN

arr	col 0	col 1
row 0	84	78
row 1	92	97
row 2	88	91

THE OFFSETarr[1] is the second cell — the index is an offset from the start.

Predict the Output

Read It Before You Run It

Two cells are changed, then the whole array is summed. What exactly does this program print?

#include <iostream>using namespace std;int main() { int nums[5] = {10, 20, 30, 40, 50}; nums[1] = 25; nums[3] += 5; int sum = 0; for (int i = 0; i < 5; i++) { sum += nums[i]; } cout << nums[0] << " " << nums[4] << endl; cout << sum << endl; return 0;}

CHOOSE THE EXACT OUTPUTTWO LINES ARE PRINTED

CHOOSE ONE

WATCHThe print statements run after the modifications, not before them.

Find the Bug

Find It, Then Fix It

Press Reveal fix to repair one line at a time. The corrected line turns green in the code panel, and the card beside it keeps the before/after pair.

BUGGY CODE

void printAll(int arr[], int size) { for (int i = 0; i <= size; i++) cout << arr[i] << " ";}int main() { int scores[5] = {70, 80, 90, 60, 75}; int bonus = 0; for (int i = 0; i < 3; i++) // first three scores bonus += scores[i + 1]; scores[5] = 100; printAll(scores, 5); cout << endl << bonus << endl;}

TASKThree bugs are hiding in this program. Find each one before you press Reveal fix.

BUG 1LOOP BOUND

i <= size→i < size

When size is 5, i <= size reads arr[5] — one cell past the array. The loop must stop before size.

BUG 2WRONG INDEX

scores[i + 1]→scores[i]

The loop is meant to add the first three scores, but i + 1 skips scores[0] and adds 80, 90 and 60 instead.

BUG 3OUT OF BOUNDS

scores[5] = 100→scores[4] = 100

The last valid cell is scores[4]. Writing to scores[5] goes past the end of the array.

AFTER ALL THREEThe loop stays inside scores[0..4], and the first three scores add to 240.

2D Array Visualization

Read the Table

Each expression points at one cell. Predict its value, then reveal the cell and check the highlight.

int arr[3][3]3 ROWS × 3 COLUMNS

arr	Exam 1	Exam 2	Exam 3
Student 1	84	78	90
Student 2	92	97	85
Student 3	88	91	79

arr[0][1]?PREDICT

arr[2][0]?PREDICT

arr[1][2]?PREDICT

0 / 3 REVEALED

FORMarr[row][col]

ROWthe first bracket — which row

COLthe second bracket — which column

EXAMPLEarr[0][1] = row 0, column 1

EXAMPLEarr[2][0] = row 2, column 0

COMMON SLIParr[1][2] means row 1, column 2 — not row 1, column 3.

BOTH START AT 0The row index and the column index are independent. Each one starts at zero.

Code Writing

Write It Line by Line

Three tasks, one array. Write each loop yourself first, then use the stepper to reveal the solution one line at a time and check your structure.

a	col 0	col 1	col 2
row 0	8	6	10
row 1	4	9	8
row 2	12	6	3

ASSUMEint a[3][3] is already declared with these values.

TASK 1Write one nested loop that adds all nine cells, then prints the total.

int total = 0;for (int row = 0; row < 3; row++) { for (int col = 0; col < 3; col++) { total += a[row][col]; }}cout << total << endl;

BLANK

WRITEWrite one nested loop that adds all nine cells, then prints the total.

Section 2 — Linked Lists

Pointers, Not Boxes

Nothing here is new. Five pointer rules, applied six times — insert, delete, and the two operations that only read.

Nodes · head & tail · Insert · Delete · Traverse

Section 2 · Linked Lists

The Pointer Contract

Every insert, delete and search in this section is just these five rules being restored after something changed.

IDEAREMEMBER

NodeA data value and a next pointer — the value, and the address that follows it.

headPoints at the first node; nullptr only when the list is empty.

tailPoints at the last node; nullptr only when the list is empty.

EndThe last node's next is always nullptr.

WalkOne loop reads every list: follow next until it is nullptr.

THREE NODES, TWO POINTERShead / tail / nullptr

head

data10next•

data20next•

tail

data30next•

nullptr

Node* temp = head;while (temp != nullptr) { cout << temp->data << " "; temp = temp->next;}

THE RULEIf a next pointer is not reassigned, nothing moves. A link only exists once it is written.

Predict the Output

Six Calls, One List

Track head and tail after each call. The position argument is 1-based; the loop that finds it is not.

LinkedList list;list.insertAtEnd(10);list.insertAtEnd(20);list.insertAtBeginning(5);list.insertAtPosition(15, 3);list.deleteAtEnd();list.traverse();

CHOOSE THE EXACT OUTPUTtraverse() PRINTS ONE LINE

CHOOSE ONE

WATCHinsertAtPosition(15, 3) inserts after the second node, not before the third.

Find the Bug

Find It, Then Fix It

Three pointer bugs. Press Reveal fix to repair one line at a time — the corrected line turns green, and the card keeps the before/after pair.

BUGGY CODE

void insertAtPosition(int value, int position) { Node* temp = head; for (int i = 1; i < position; i++) temp = temp->next; Node* newNode = new Node(value); newNode->next = newNode; temp->next = newNode;}void deleteAtPosition(int pos) { Node* temp = head; for (int i = 1; i < pos - 1; i++) temp = temp->next; Node* toDelete = temp->next; temp->next = toDelete->next; if (temp->next == nullptr) tail = temp->next; delete toDelete;}

TASKTwo functions, three defects. Find each one before you press Reveal fix.

BUG 1LOOP BOUND

i < position→i < position - 1

The loop must stop on the predecessor. With i < position it stops one node too far, so the new node lands after the wrong node.

BUG 2LINK ORDER

newNode->next = newNode→newNode->next = temp->next

Pointing the new node at itself creates a one-node loop. It must first capture the node it is pushing forward, then the predecessor is re-linked.

BUG 3TAIL UPDATE

tail = temp->next→tail = temp

After deleting the last node, the new tail is the predecessor — temp. Assigning temp->next sets tail to nullptr while the list is not empty.

AFTER ALL THREEThe predecessor is found, the new node points forward, and tail always names a node that exists.

Insert in the Middle

The Order Is the Lesson

The new node has to point forward before the predecessor points at it. Reverse the two assignments and the rest of the list is lost.

START5 → 10 → 20 → 30 → nullptr

AFTER5 → 10 → 15 → 20 → 30 → nullptr

FIRSTnewNode->next = temp->next

THENtemp->next = newNode

POSITION 1Front insertion is a separate branch — it has no predecessor to find.

START — 5, 10, 20, 30POSITION 3 → PREDECESSOR IS 10

head

data5next•

temp

data10next•

data20next•

tail

data30next•

nullptr

LINK FORWARD FIRST15 POINTS AT 20

head

data5next•

temp

data10next•

new

data15next•

data20next•

tail

data30next•

nullptr

THEN RE-LINK tempRESULT: 5 → 10 → 15 → 20 → 30

head

data5next•

data10next•

data15next•

data20next•

tail

data30next•

nullptr

Code Writing

Write It Line by Line

Three methods, three different failure points. Write each one first, then reveal the solution one line at a time.

TASKWHAT MUST STAY TRUE

Insert endAn empty list moves both head and tail.

Delete firstMove head before freeing, and reset tail if the list empties.

SearchReturn on the match; reaching nullptr means not found.

ASSUMENode and the class with head / tail already exist.

TASK 1Append a new node at the end, keeping head and tail correct.

Node* newNode = new Node(value);if (head == nullptr) { head = tail = newNode; return;}tail->next = newNode;tail = newNode;

BLANK

WRITEAppend a new node at the end, keeping head and tail correct.

Section 3 — Recursive Functions

A Function That Trusts Itself

Three parts every time: a base case that stops, a smaller call that moves, and a stack that unwinds.

Base case · Smaller call · Stack frames · Unwind

Section 3 · Recursion

Three Rules, No Exceptions

A recursive function is not a loop written differently. It is a contract with three clauses, and a missing clause shows up as a crash.

PARTWHAT IT MUST DO

Base caseReturn without calling itself. Every chain must be able to reach this line.

Recursive caseCall the same function — that is the whole idea.

ProgressEach call takes a smaller argument, so the base case gets closer.

UnwindResults return in reverse order: the last call finishes first.

int fact(int num) { if (num == 0) return 1; // base case return num * fact(num - 1); // smaller argument}

TRACE ITfact(4) = 4 × 3 × 2 × 1 × 1 = 24. The final 1 is the base case, not a multiplication.

Predict the Output

Two Functions, One Chain

Neither function calls itself — they call each other. Follow the argument down, not the name of the function.

void functionB(int n); // forward declarationvoid functionA(int n) { if (n <= 0) return; cout << "A: " << n << endl; functionB(n - 1);}void functionB(int n) { if (n <= 0) return; cout << "B: " << n << endl; functionA(n - 1);}int main() { functionA(4);}

CHOOSE THE EXACT OUTPUTONE LINE PER PRINT

CHOOSE ONE

KEYThe argument drops by one on every hop, even though the function name changes.

Find the Bug

Find It, Then Fix It

Three functions, three broken clauses of the contract. Press Reveal fix to repair one line at a time.

BUGGY CODE

int fact(int num) { if (num == 0) return 0; return num * fact(num - 1);}int power(int base, int exp) { if (exp == 1) return base; return base * power(base, exp - 1);}void countdown(int n) { if (n == 0) return; cout << n << " "; countdown(n);}

TASKEach function breaks a different rule. Find the clause before you press Reveal fix.

BUG 1WRONG BASE VALUE

return 0→return 1

The base case stops the recursion but answers the wrong number. fact then multiplies by 0, so every result becomes 0.

BUG 2WRONG BOUNDARY

if (exp == 1)→if (exp == 0)

power(x, 0) must return 1. With exp == 1 the call for 0 never matches, keeps subtracting, and runs past zero.

BUG 3NO PROGRESS

countdown(n)→countdown(n - 1)

The same argument goes to every call, so n never reaches 0 and the base case is never seen. The stack grows until it overflows.

AFTER ALL THREEEach function now has a base case, and each call is strictly closer to it.

The Call Stack

Watch It Unwind

Every call pauses at num * fact(num - 1) and waits. Nothing is multiplied until the base case returns the first value.

DOWN4 → 3 → 2 → 1 → 0

BASEfact(0) = 1

UP1 → 2 → 6 → 24

RESULTfact(4) = 24

WHY IT MATTERSDepth uses memory. Deep or endless recursion overflows the stack — the crash is the missing clause.

FACT(4) — LIVE TRACECALL STACK · 15 STEPS

CALL STACKempty

RETURNING—

int fact(int num) { if (num == 0) return 1; else return num * fact(num - 1);}

Start — main calls fact(4). Nothing is on the stack yet.

START

Code Writing

Write It Line by Line

Three recursion shapes: a value, a void printer, and a mutually recursive pair. Write each one first, then reveal the solution.

TASKTHE CLAUSE TO GET RIGHT

FactorialBase returns 1; the general case multiplies.

CountdownBase returns before printing; each call prints then recurses.

Indirect pairBoth functions need the guard, not just the first one.

REMEMBERA recursive call is a normal call: it stops the current frame until it returns.

TASK 1Write fact(num) so that fact(0) is 1 and every other call multiplies.

int fact(int num) { if (num == 0) return 1; return num * fact(num - 1);}

BLANK

WRITEWrite fact(num) so that fact(0) is 1 and every other call multiplies.

Section 4 — Stacks

One End, No Exceptions

Everything happens at the top. An array stack can fail in exactly two ways: it is full, or it is empty.

LIFO · top · push · pop · overflow · underflow

Section 4 · Stacks

Five Operations, One Index

A stack is an array plus one integer. Every operation is a guard, a move of top, and one read or write.

OPERATIONWHAT IT DOES TO top

pushInsert at the top; top moves up before the write.

popRemove the top; read first, then top moves down.

peekRead arr[top] without moving anything.

isEmptytop == -1 means empty.

isFulltop == MAX - 1 means full.

THE STACK GROWS UPTHREE VALUES, FIVE CELLS

top [2]

[0]10

[1]20

[2]30

[3]—

[4]—

THE STATEtop is the only thing the class keeps. The values live in arr; the meaning lives in the index.

Predict the Output

Five Cells, One Wasted Push

Track top, not the values. A pop frees a cell, and capacity is counted from the index, not from how many calls you have made.

const int MAX = 5;Stack s;s.push(10); s.push(20); s.push(30);s.pop(); s.pop();s.push(40); s.push(50);s.push(60); s.push(70); s.push(80);s.display();

CHOOSE THE EXACT OUTPUTONE MESSAGE AND ONE LINE OF ELEMENTS

CHOOSE ONE

WATCHtop is a counter, so capacity is a state, not the number of elements printed.

Find the Bug

Find It, Then Fix It

Three methods, one broken line each. Press Reveal fix to repair them in order — the corrected line turns green.

BUGGY CODE

void push(int value) { if (isFull()) return; arr[top] = value;}void pop() { if (isEmpty()) return; cout << arr[top] << " popped" << endl; top++;}bool isFull() { return top == MAX;}

TASKThree defects, one per method. Find each line before you press Reveal fix.

BUG 1OFF-BY-ONE

arr[top] = value→arr[++top] = value

The first push writes arr[-1] because top starts at -1. It must move up before the value is stored.

BUG 2WRONG DIRECTION

top++→top--

The value is printed correctly but the stack never shrinks, so the same value is popped forever.

BUG 3ONE PAST THE END

top == MAX→top == MAX - 1

Index MAX does not exist, so the guard never fires in time and the next write lands past the array.

AFTER ALL THREEtop moves in the right direction, at the right moment, and stops at the last valid cell.

Push and Pop

Watch top Move

Both operations touch one cell and one index. Only the order of the two steps changes.

PUSHtop++ then arr[top] = value

POPread arr[top] then top--

PEEKread only

WHYThe order of the two steps is the whole difference between a correct stack and a silent bug.

ARRAY STACK — LIVEtop [2] · 3 OF 5 CELLS

top [2]

[0]10

[1]20

[2]30

[3]—

[4]—

STACK — TOP TO BASE30 → 20 → 10

void display() { if (isEmpty()) { cout << "Stack is empty." << endl; } else { cout << "Stack elements (top to bottom): "; for (int i = top; i >= 0; i--) { cout << arr[i] << " "; } cout << endl; }}int main() { Stack s; s.push(10); s.push(20); s.push(30); s.display(); s.peek(); s.pop(); s.pop(); s.display(); return 0;}

CONSOLE OUTPUTLIVE

10 pushed into stack.20 pushed into stack.30 pushed into stack.Stack elements (top to bottom): 30 20 10

display() starts at i = top and walks down to 0: 30, then 20, then 10.

STEP 4 / 8

Code Writing

Write It Line by Line

Three methods, one index between them. Write each one first, then reveal the solution one line at a time.

TASKTHE ORDER TO GET RIGHT

PushGuard, move top, then write.

PopGuard, read, then move top.

PeekGuard, read only.

ASSUMEarr[MAX] and top already exist.

TASK 1Add a value on top of the array stack, refusing when it is full.

if (isFull()) return;arr[++top] = value;

BLANK

WRITEAdd a value on top of the array stack, refusing when it is full.

Section 5 — Queues

First In, First Out

The front only moves forward. That single fact creates both the simple queue and the circular fix.

front · rear · enqueue · dequeue · modulo

Section 5 · Queues

Two Pointers, One Direction

A queue is two indices on one array. Every operation is a guard plus a pointer move — and the guard is where the marks are usually lost.

IDEAREMEMBER

enqueueInsert at rear, the only place new work enters.

dequeueRemove from front, the only place work leaves.

simple fullrear == SIZE - 1; space at the front is never reused.

circular full(rear + 1) % C_SIZE == front, which also catches the wrap case.

emptyfront == -1.

A SIMPLE QUEUEfront → 0 · rear → 2

rear

[0]10

[1]20

[2]30

[3]—

[4]—

front

THE PROBLEMfront only ever increases. The two cells behind it still hold values, but nothing will ever read them again.

Predict the Output

Full With Three Free Cells

Five cells, three values. Trace front and rear after every call — the last enqueue is the one that matters.

const int SIZE = 5;SimpleQueue q;q.enqueue(10);q.enqueue(20);q.enqueue(30);q.dequeue();q.dequeue();q.enqueue(40);q.enqueue(50);q.enqueue(60);q.display();

CHOOSE THE EXACT OUTPUTONE MESSAGE AND ONE LINE OF ELEMENTS

CHOOSE ONE

WHYThat refusal is the limitation, not a mistake in the code. The circular queue removes it by letting rear wrap back to cell 0.

Find the Bug

Find It, Then Fix It

A circular queue with three defects, all in the pointer arithmetic. Press Reveal fix to repair one line at a time.

BUGGY CODE

void enqueue(int value) { if (isFull()) return; if (isEmpty()) front = rear = 0; else rear++; items[rear] = value;}void dequeue() { if (isEmpty()) return; if (front == rear) { front = rear = 0; } else { front = (front + 1) % C_SIZE; }}bool isFull() { return rear + 1 == front;}

TASKOne class, three broken lines. Find each defect before you press Reveal fix.

BUG 1NO MODULO

rear++→rear = (rear + 1) % C_SIZE

Without the modulo the rear walks off the end of the array instead of wrapping to 0. The next write lands outside items[].

BUG 2EMPTY NEVER RESETS

front = rear = 0→front = rear = -1

After the last element leaves, both pointers must return to -1 or the queue can never be empty again — isEmpty() tests front == -1.

BUG 3INCOMPLETE FULL

rear + 1 == front→(rear + 1) % C_SIZE == front

The full check must wrap too, or it misses the case where rear sits on the last cell and the only free slot is index 0.

AFTER ALL THREEThe rear wraps, an emptied queue resets to -1, and the full check is circular as well. All three fixes are the same idea: modulo.

The Wrap-Around

The Array Becomes a Ring

Five cells, five values. Two dequeues and two enqueues are enough to leave the rear sitting behind the front.

FULLfront → 0, rear → 4

DEQUEUEfront = (front + 1) % 5

ENQUEUErear = (4 + 1) % 5 = 0

READ THE ORDERThe array reads 60, 70, 30, 40, 50. The queue reads 30, 40, 50, 60, 70. Array order and queue order are different things.

BEFORE — THE QUEUE IS FULLfront → 0 · rear → 4

rear

[0]10

[1]20

[2]30

[3]40

[4]50

front

AFTER — THE REAR WRAPPEDfront → 2 · rear → 1

rear

[0]60

[1]70

[2]30

[3]40

[4]50

front

LOGICAL ORDERWalking from front to rear and wrapping as it goes: 30, 40, 50, 60, 70. Nothing was shifted and no cell was wasted.

Code Writing

Write It Line by Line

Three methods, three pointer moves that must be wrapped. Write each one first, then reveal the solution one line at a time.

TASKWHAT MUST STAY TRUE

EnqueueGuard, handle the empty case, then wrap the rear.

DequeueGuard, reset both pointers when the last element leaves, otherwise wrap the front.

DisplayWalk from front to rear with the same modulo.

REMEMBEREvery pointer move in a circular queue needs % C_SIZE — the rear when inserting, the front when removing, and the walk in display().

TASK 1Add a value at the rear of the circular queue.

if (isFull()) return;if (isEmpty()) front = rear = 0;else rear = (rear + 1) % C_SIZE;items[rear] = value;

BLANK

WRITEAdd a value at the rear of the circular queue.

Section 6 — Binary Search Trees

Order Is the Structure

A BST is not a shape you draw. It is one ordering rule, applied recursively at every node.

left < node < right · pre · in · post · node count

Section 6 · BST

One Rule, Applied Everywhere

Everything in this section is one sentence read in a different order. Get the sentence right and the traversals write themselves.

IDEAREMEMBER

PropertyEverything in the left subtree is smaller; everything on the right is larger.

Nodedata, left, right — a leaf has two nullptrs.

Pre-orderRoot, then left, then right.

In-orderLeft, root, right — always sorted.

Post-orderLeft, right, then root.

Count1 + count(left) + count(right).

THE ASSIGNMENT TREEINSERT 50, 30, 70, 20, 40, 60, 80

50

30

70

20

40

60

80

READ ITIn-order reads the values in sorted order: 20, 30, 40, 50, 60, 70, 80.

Predict the Output

Children Before the Parent

The three recursive calls only differ in where the print sits. Here the print is last, so nothing is printed until both subtrees are done.

void printPostorder(Node* root) { if (root == nullptr) return; printPostorder(root->left); printPostorder(root->right); cout << root->data << " ";}

CHOOSE THE EXACT OUTPUTPOST-ORDER OF 50, 30, 70, 20, 40, 60, 80

CHOOSE ONE

KEYThe root is always last in post-order, because it waits for both subtrees to finish.

Find the Bug

Find It, Then Fix It

Three defects in one insert and one search. Press Reveal fix to repair one line at a time — the corrected line turns green, and the card keeps the before/after pair.

BUGGY CODE

Node* insert(Node* root, int value) { if (root == nullptr) return new Node(value); if (value > root->data) root->left = insert(root->left, value); else root->right = insert(root->right, value); return root;}bool search(Node* root, int key) { while (root != nullptr) { if (key == root->data) return true; if (key < root->data) root = root->left; else root = root->left; } return true;}

TASKTwo functions, three defects. Find each one before you press Reveal fix.

BUG 1INVERTED COMPARISON

value > root->data→value < root->data

With the comparison inverted, larger values go left, so the tree no longer satisfies its own rule.

BUG 2WRONG BRANCH

else root = root->left→else root = root->right

Search follows the left child twice, so the whole right subtree is unreachable.

BUG 3FALSE POSITIVE

return true→return false

Falling out of the loop means the key was never found; returning true makes every miss a success.

AFTER ALL THREESmaller values go left, larger go right, and a walk that runs out of nodes reports false.

Building the Tree

One Comparison per Level

Insert never redraws the tree. It compares once per level and stops at the first empty pointer it reaches.

SMALLERroot->left = insert(root->left, value)

LARGERroot->right = insert(root->right, value)

EMPTYreturn new Node(value)

ONE POINTEROnly the empty pointer the walk stopped at changes. Every ancestor hands the same root back up.

WHERE 20 LANDS50 → 30 → LEFT

50

30

70

20

40

60

80

COMPARISON PATHINSERT 20

50 → 30 → nullptr → Node(20)

THE WALKTwo comparisons, two left turns: 20 lands on 30's empty left child.

Code Writing

Write It Line by Line

Three functions, one rule. Write each one first, then reveal the solution one line at a time and check where the recursion returns.

TASKWHAT MUST STAY TRUE

InsertSmaller left, larger right, and keep the returned subtree.

SearchCompare, turn once, stop on nullptr.

Node countOne, plus both subtrees.

REMEMBEREvery recursive function here returns the node or subtree it was given.

TASK 1Insert a value while preserving left < node < right.

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);return root;

BLANK

WRITEInsert a value while preserving left < node < right.

End of Revision

Best Wishes!

Good Luck in Your Midterm Exam

You've got this. Do your best!

#include <iostream>using namespace std;int main() { cout << "Best wishes!" << endl; cout << "Good luck in your midterm." << endl; return 0;}

OUTPUTEXIT 0

Best wishes!
Good luck in your midterm.

End of Revision

Best Wishes!

Good Luck in Your Midterm Exam

You've got this. Do your best!