The final part of my June 2025 Paper 1 (9618/12) walkthrough, covering relational databases and SQL, arrays vs linked lists, and algorithm tracing. These are the topics where careful, precise answers separate the top grades — so let's go through what examiners actually look for.
📄 The original paper and mark scheme are on the Cambridge International past papers page. Questions below are paraphrased and explained in my own words, with my own examples.
Relational databases & SQL
One question asked candidates to define a primary and foreign key, give a benefit of normalisation, and write an SQL query.
The key concepts, precisely. A primary key is an attribute (or combination) that uniquely identifies each record in a table. A foreign key is an attribute in one table that references the primary key of another table — this is what links tables in a relational database.
The misconception that costs marks: thinking a foreign key must be unique. It needn't be — in its own table the same foreign key value can appear many times (lots of orders can reference the same customer). What matters is that it matches a primary key in the related table.
Normalisation organises data to remove redundancy (storing the same fact once) and avoid update, insert and delete anomalies — which keeps the data consistent and saves storage.
SQL — write it cleanly. SQL manipulates and queries data with statements like SELECT, INSERT, UPDATE and DELETE. A SELECT follows the pattern what columns → from which table → under what condition. For example, to list every student awarded an A grade:
sql
SELECT StudentName
FROM Students
WHERE Grade = 'A';Use * if you want all columns, and remember string values go in quotes. Examiners are strict about the keyword order (SELECT … FROM … WHERE …) and the semicolon.
✏️ Practice it: "Write an SQL statement that selects the names and ages of all members in a Members table who are older than 18."Arrays & linked lists
Another question asked candidates to compare arrays and linked lists, then show how a linked list changes when an item is inserted.
The trade-off is the whole topic — neither is simply "better," and saying so loses marks:
| Array | Linked list | |
|---|---|---|
| Size | Fixed when declared | Dynamic — grows/shrinks at runtime |
| Memory | Contiguous block | Scattered nodes joined by pointers |
| Access | Direct by index (fast random access) | Sequential — follow pointers from the start |
| Best for | Frequent lookups by position | Frequent insertions/deletions |
Inserting into a linked list — describe the pointer changes in order: create the new node and store its data; set the new node's pointer to point to the node that should follow it; then update the previous node's pointer to point to the new node. Getting that order right (point the new node forward before you redirect the previous one) is what avoids losing the rest of the list.
✏️ Practice it: "A program needs a structure that constantly adds and removes items but rarely looks them up by position. State whether an array or a linked list is more suitable and justify your choice."
Algorithms & pseudocode (tracing)
The final question gave a piece of pseudocode and asked candidates to trace it with given inputs and state the output.
How to trace without slipping up. Build a trace table — one column per variable, plus one for any output. Then execute the pseudocode one line at a time, writing the new value in the relevant column whenever a variable changes. Don't skip rows and don't try to do it in your head; the marks are for the intermediate values, not just the final answer.
The common errors: forgetting to record the initial value of a variable, miscounting loop iterations (especially off-by-one at the start or end of a FOR range), and not updating a counter or running total on every pass. Track the loop condition explicitly each time round.
It also helps to recognise what the algorithm is doing — many trace questions are a standard pattern in disguise (a running total, finding a maximum, a linear search, or a swap-based sort).
✏️ Practice it: "Trace this with input 4: settotalto 0;FOR i ← 1 TO 4dototal ← total + i; outputtotal. Show every value ofiandtotal."
Quick recap
- Databases: a primary key is unique; a foreign key references another table's primary key and needn't be unique. Normalisation removes redundancy; SQL is
SELECT … FROM … WHERE …. - Data structures: arrays = fixed, indexed, fast lookup; linked lists = dynamic, pointer-linked, better for insert/delete. Insertion = create node → point it forward → redirect previous node.
- Tracing: use a trace table, one line at a time, and record initial values and every loop pass.
