[7.3] Explain algorithms

Explaining Algorithms: Purpose and Processes

From problem to precise, step-by-step solutions

An algorithm is a finite, ordered set of steps that solves a problem. When an exam question says “explain the purpose and processes of a given algorithm”, you must clearly state what the algorithm achieves (its purpose) and how it achieves it (its process or logic). Good explanations identify inputs and outputs, describe the control flow (sequence, selection, and iteration), and show the effect on data as the algorithm runs. Where helpful, you should perform a short dry run with typical, boundary, and erroneous data to demonstrate understanding.

Think of an algorithm as a recipe: purpose is “bake a sponge cake”, while process is the specific sequence of measuring, mixing, and baking. In computing we describe processes using flowcharts and pseudocode, and sometimes include a reference implementation (e.g. Python) to consolidate understanding.

How to explain an algorithm

A four-part framework

1. State the purpose: a one-sentence summary such as “This algorithm searches a list for a target value and returns its index if found, otherwise −1”.
2. Specify the interface: inputs (names and data types), outputs/side effects, and any assumptions or preconditions (e.g. “the list is sorted ascending”).
3. Describe the process: walk through the main loop and decisions. Name the variables and explain when they change.
4. Demonstrate with a dry run: show how variables evolve for at least one normal case and one edge case (e.g. target at first or last position, not present).

Worked examples with contrasts

Reading and explaining common algorithms

Below are tabbed examples that highlight the same concept across contrasting scenarios. Notice how the explanation structure stays consistent while details change.

Searching a list: purpose, process, and assumptions

• Linear Search: No Assumptions
• Binary Search: Sorted List Assumption
• Edge Case: Value Not Present

// CAIE Pseudocode: Linear Search
// Returns index if found, otherwise -1
FUNCTION LinearSearch(list: ARRAY OF INTEGER, target: INTEGER) RETURNS INTEGER
    FOR i ← 0 TO LENGTH(list) - 1
        IF list[i] = target THEN
            RETURN i
        ENDIF
    NEXT i
    RETURN -1
ENDFUNCTION

# Python: Linear search
def linear_search(items, target):
    for i, v in enumerate(items):
        if v == target:
            return i
    return -1

// CAIE Pseudocode: Binary Search (iterative)
FUNCTION BinarySearch(list: ARRAY OF INTEGER, target: INTEGER) RETURNS INTEGER
    DECLARE low INTEGER ← 0
    DECLARE high INTEGER ← LENGTH(list) - 1
    WHILE low ≤ high DO
        DECLARE mid INTEGER ← (low + high) DIV 2
        IF list[mid] = target THEN
            RETURN mid
        ELSEIF target < list[mid] THEN
            high ← mid - 1
        ELSE
            low ← mid + 1
        ENDIF
    ENDWHILE
    RETURN -1
ENDFUNCTION

# Python: Binary search (iterative)
def binary_search(items, target):
    low, high = 0, len(items) - 1
    while low <= high:
        mid = (low + high) // 2
        if items[mid] == target:
            return mid
        elif target < items[mid]:
            high = mid - 1
        else:
            low = mid + 1
    return -1

Explaining algorithms that modify data

Example: Bubble Sort with contrasts

Some algorithms transform data structures. For sorting, a clear explanation should include the invariant (what remains true after each pass), the swapping step, and a halting condition.

• Core Idea: Adjacent Swaps
• With Early-Exit Optimisation
• Common Mistake: Off-by-One

// CAIE Pseudocode: Bubble Sort (basic)
PROCEDURE BubbleSort(list: ARRAY OF INTEGER)
    FOR pass ← 0 TO LENGTH(list) - 2
        FOR i ← 0 TO LENGTH(list) - 2 - pass
            IF list[i] > list[i+1] THEN
                // swap
                DECLARE temp INTEGER ← list[i]
                list[i] ← list[i+1]
                list[i+1] ← temp
            ENDIF
        NEXT i
    NEXT pass
ENDPROCEDURE

# Python: Bubble sort (basic)
def bubble_sort(a):
    n = len(a)
    for p in range(n - 1):
        for i in range(n - 1 - p):
            if a[i] > a[i + 1]:
                a[i], a[i + 1] = a[i + 1], a[i]

Dry runs and trace tables

Show variable changes step by step

Trace tables help you justify your explanation. Include columns for the loop counters, key variables, and outputs. Record values after each important step or iteration. You do not need every minor change—focus on the variables that drive decisions.

Clarity checklist for your explanations

What examiners look for

• Purpose is stated precisely, including the “not found” or error behaviour if relevant.
• Inputs and outputs are named and typed; any preconditions (e.g. “sorted list”) are explicit.
• Process covers the main loop and key decisions succinctly, using correct terminology.
• Dry run demonstrates understanding on normal and edge cases.
• Correctness conditions (e.g. loop bounds, swap positions) are accurate; common mistakes are avoided.