Algorithms and computational thinking overview - Eduqas GCSE Computer Science
A deep-dive guide to algorithms and computational thinking in Eduqas GCSE Computer Science: abstraction and decomposition, designing and tracing algorithms with pseudocode and flowcharts, linear and binary search, bubble and merge sort, logic gates and Boolean expressions, and the software development life cycle.
Reviewed by: AI editorial process; not yet individually human-reviewed
Jump to a section
This module covers how problems are solved computationally: the thinking techniques, the algorithms you must know, and the logic that underlies a computer. It also includes the software development life cycle. Each section links to a focused answer page with worked Eduqas exam questions.
Computational thinking
Computational thinking has three parts. Abstraction removes unnecessary detail to focus on what matters; decomposition breaks a large problem into smaller sub-problems that can each be solved and tested separately; and algorithmic thinking works out the precise, ordered steps to solve the problem. See the computational thinking page.
Designing and tracing algorithms
Algorithms are expressed in pseudocode (structured text) or flowcharts (boxes joined by arrows, using the terminator, process, input/output and decision symbols). A trace table follows an algorithm by recording each variable as the steps run, which finds the output and reveals mistakes. See the designing algorithms page.
Searching and sorting
The two searches are linear (check each item in turn, any list) and binary (check the middle of a sorted list and discard half each step, much faster but needs sorted data). See the searching page. The two sorts are bubble (compare adjacent pairs and swap, repeating passes, simple but slow) and merge (split in half repeatedly then merge the sorted parts, far faster on large lists). See the sorting page.
Logic gates and Boolean expressions
A computer is built from logic gates: AND (output 1 only when both inputs are 1), OR (1 when at least one input is 1) and NOT (inverts its single input). A truth table lists every input combination and the output, and you combine the gates in Boolean expressions of up to three inputs. See the logic gates page.
The software development life cycle
Although programming detail sits in the programming module, the software development life cycle belongs to this design-focused topic. A program passes through analysis (identify the problem and requirements), design (plan algorithms, data and interface), development/coding (write it), testing (check it with normal, boundary and erroneous data), implementation (deploy it) and evaluation (check it meets the requirements and find improvements). Testing runs throughout, not just at the end, so errors are found early. This is why decomposition matters: each sub-problem can be designed, built and tested on its own before the parts are combined.
How to revise this topic
- Learn the three computational-thinking terms precisely. Abstraction, decomposition and algorithmic thinking each have a clean definition and a reason they help.
- Practise trace tables. Following an algorithm pass by pass, one row per change, is a high-value, frequently tested skill.
- Know the four algorithms cold. Be able to describe linear and binary search and bubble and merge sort, and compare their efficiency and requirements.
- Drill truth tables. AND, OR and NOT, and combined expressions up to three inputs, are recurring marks where method (intermediate columns) matters.
Test yourself with the algorithms and computational thinking quiz, then work through each dot-point page for the full worked exam questions.