AQA GCSE Computer Science 3.1 Fundamentals of algorithms: computational thinking, flowcharts, pseudocode, searching and sorting

What area 3.1 actually demands

Fundamentals of algorithms is where AQA tests problem solving. You need to think computationally about a problem, represent the solution clearly as a flowchart or in pseudocode, and know the four standard algorithms (two for searching, two for sorting) well enough to trace and compare them. This area is examined mainly in Paper 1 alongside programming.

This guide ties together the four dot-point pages for the area: computational thinking, flowcharts and pseudocode, searching algorithms, and sorting algorithms.

Computational thinking

The starting point is computational thinking, broken into three techniques. Abstraction removes unnecessary detail so you can focus on what matters, like a train map that hides exact distances. Decomposition breaks a large problem into smaller, easier sub-problems. Algorithmic thinking works out the precise, ordered steps to solve each part. Together they turn a messy real-world problem into a clear algorithm.

Remember the definition that an algorithm is a sequence of steps that solves a problem, and that a program is that algorithm written in a language a computer can run.

Representing algorithms

You must read and write algorithms in two forms. A flowchart uses standard symbols (oval for start and stop, rectangle for a process, parallelogram for input and output, diamond for a decision) joined by arrows. Pseudocode is language-neutral structured text, and AQA publishes its own notation using <- for assignment and keywords such as IF, WHILE and FOR. Learning the AQA notation matters because exam algorithms are often presented in it.

Searching algorithms

Two searches are required. A linear search checks each item in turn from the start until it finds the target or reaches the end; it works on any list but may need up to $n$ comparisons. A binary search works only on a sorted list, repeatedly checking the middle item and discarding the half that cannot contain the target, so it needs at most about $\log_2 n$ comparisons and is far faster on large lists.

Sorting algorithms

Two sorts are required. A bubble sort repeatedly compares adjacent pairs and swaps them if they are in the wrong order, passing through the list until no swaps occur; it is simple but slow, needing up to about $n^2$ comparisons. A merge sort uses divide and conquer: split the list to single items, then merge sub-lists back in order, needing about $n \log_2 n$ operations, so it is much faster on large lists but uses more memory.

Check your knowledge

A mix of recall and tracing questions covering area 3.1. Attempt them, then check against the solutions.

1. Name the three techniques of computational thinking. (3 marks)
2. State the difference between an algorithm and a program. (2 marks)
3. Name the flowchart symbol used for input or output. (1 mark)
4. State one condition that must be true for a binary search to work. (1 mark)
5. A sorted list has 256 items. State the maximum number of comparisons a binary search needs. (1 mark)
6. Describe the main idea of a bubble sort. (2 marks)
7. State which technique merge sort is based on. (1 mark)
8. Give one advantage of bubble sort over merge sort. (1 mark)