Algorithmic Thinking

Algorithmic thinking is one of the four pillars of computational thinking. It involves designing a clear, step-by-step solution (an algorithm) to solve a problem. An algorithm is a precise set of instructions that, when followed, will produce the correct output for any valid input. Algorithmic thinking is central to GCSE Computer Science — you must be able to design, interpret, and evaluate algorithms.

---

What is an Algorithm?

An algorithm is a finite sequence of well-defined instructions that solves a specific problem or performs a specific task. Algorithms have several key properties:

• Precise — each step is unambiguous and clearly defined
• Finite — the algorithm must eventually terminate (stop)
• Effective — each step can actually be carried out
• General — the algorithm works for all valid inputs, not just one specific case

Everyday Algorithms

Algorithms are not limited to computers. Everyday examples include:

• A recipe for baking a cake
• Directions to get from home to school
• Instructions for assembling flat-pack furniture
• The rules of a board game

However, in computer science, algorithms must be precise enough for a computer to follow. A computer cannot interpret vague instructions like "add a pinch of salt" — it needs exact values and conditions.

---

Designing Algorithms

When designing an algorithm, follow these steps:

1. Understand the problem — What are the inputs? What is the expected output?
2. Plan the approach — What steps are needed to transform the inputs into the output?
3. Write the algorithm — Express the steps in pseudocode, a flowchart, or structured English
4. Test the algorithm — Trace through it with sample data to check it works (a dry run or trace table)
5. Refine if necessary — Fix any errors or improve efficiency

Example: Finding the Maximum Value

Problem: Given a list of numbers, find the largest one.

Inputs: A list of numbers Output: The largest number in the list

Algorithm in pseudocode:

max ← list[0]
FOR i ← 1 TO LENGTH(list) - 1
    IF list[i] > max THEN
        max ← list[i]
    END IF
END FOR
OUTPUT max

Trace table for the list [3, 7, 2, 9, 4]:

Step	i	list[i]	max	Condition (list[i] > max)
Init	—	—	3	—
1	1	7	7	TRUE
2	2	2	7	FALSE
3	3	9	9	TRUE
4	4	4	9	FALSE

Output: 9

The full design loop — from problem to trace — looks like this:

graph LR
    P["Problem<br/>Find largest<br/>in a list"] --> A["Algorithm<br/>Initialise max,<br/>loop, compare,<br/>update"]
    A --> C["Code/Pseudocode<br/>FOR i ... IF ..."]
    C --> T["Trace table<br/>step through<br/>each iteration"]
    T -->|verify| OK["Correct output"]
    T -.->|bug found| A

---

Key Algorithmic Constructs

All algorithms are built from three fundamental constructs:

1. Sequence

Instructions are executed one after another, in order:

INPUT radius
area ← 3.14159 * radius * radius
OUTPUT area

2. Selection (Decision Making)

The program chooses which instructions to execute based on a condition:

INPUT age
IF age >= 18 THEN
    OUTPUT "You can vote"
ELSE
    OUTPUT "You cannot vote yet"
END IF

Selection can also use nested IF statements or CASE/SWITCH statements for multiple conditions.

3. Iteration (Repetition / Loops)

Instructions are repeated either a set number of times or until a condition is met:

• Count-controlled loop (FOR):

FOR i ← 1 TO 10
    OUTPUT i * i
END FOR

• Condition-controlled loop (WHILE):

password ← ""
WHILE password ≠ "secret123"
    INPUT password
END WHILE
OUTPUT "Access granted"

• Condition-controlled loop (REPEAT...UNTIL):

REPEAT
    INPUT number
UNTIL number >= 0

Exam Tip: You must know the difference between WHILE and REPEAT...UNTIL loops. A WHILE loop checks the condition before each iteration (and may not execute at all). A REPEAT...UNTIL loop checks the condition after each iteration (and always executes at least once).

---

Trace Tables

A trace table is used to track the values of variables as an algorithm executes. It is a vital tool for:

• Dry running an algorithm to check it produces the correct output
• Debugging — finding where an algorithm goes wrong
• Understanding how an algorithm works step by step

Example: Trace Table for a Counting Algorithm

count ← 0
FOR i ← 1 TO 5
    IF i MOD 2 = 0 THEN
        count ← count + 1
    END IF
END FOR
OUTPUT count

Step	i	i MOD 2	Condition	count
Init	—	—	—	0
1	1	1	FALSE	0
2	2	0	TRUE	1
3	3	1	FALSE	1
4	4	0	TRUE	2
5	5	1	FALSE	2

Output: 2 (there are 2 even numbers between 1 and 5)

---

Efficiency of Algorithms

Not all algorithms that solve the same problem are equally good. Algorithm efficiency considers:

• Time complexity — how many steps the algorithm takes as the input size grows
• Space complexity — how much memory the algorithm uses

For GCSE, you should understand that:

• A linear search checks each item one by one — for a list of n items, it takes up to n comparisons
• A binary search halves the search space each time — for a list of n items, it takes up to log₂(n) comparisons
• More efficient algorithms are faster for large datasets

---

Summary

Algorithmic thinking is about designing clear, step-by-step solutions. All algorithms use sequence, selection, and iteration. You should be able to write algorithms in pseudocode, trace them using trace tables, and evaluate their efficiency. Algorithmic thinking is assessed throughout the GCSE Computer Science exam.

---

Extended Study: Designing, Tracing and Reasoning About Algorithms

Algorithmic thinking is the culmination of the four computational-thinking pillars. By the time you are writing an algorithm, you have already decomposed the problem, abstracted the data, spotted the patterns and decided which programming constructs to use. This section deepens each of those steps with worked examples — a quiz marker and a traffic-light controller — and ends with grade-banded model answers.

The anatomy of an algorithm

A good GCSE algorithm has five named parts: