Why is "Writing `FOR i ← 0 TO LEN(a)` instead of `FOR i ← 0 TO LEN(a) - 1`." a common mistake in Data structures?

Why it happens: `LEN` gives the number of elements, which feels like the natural upper limit — the gap between 'how many there are' and 'what the last index is' only exists because counting starts at 0. How to avoid it: Hold the relationship explicitly: an array of **n** elements has indices **0 to n−1**, so the last index is always one less than the length. Sanity-check with a small case — a 3-element array has indices 0, 1, 2. Getting this wrong causes an **out-of-range error** on the final iteration and crashes the program. Source: Off-by-one loop bounds are one of the two standard faults used in array error-identification questions on Paper 1.

Why is "Initialising a maximum-finder with `largest ← 0` instead of `largest ← a[0]`." a common mistake in Data structures?

Why it happens: Zero feels like a natural neutral starting point, and with the positive test data used in most classroom examples the algorithm produces correct answers — so the flaw never surfaces. How to avoid it: Initialise from **the data itself**: `largest ← a[0]`, then start the loop at index 1. If every value in the array were negative, nothing would ever beat 0 and the algorithm would report a value that is not even in the array. The mirror error applies to minimum-finders initialised to 0. Source: This is a logic error that produces no crash and no error message, which is precisely why examiners set all-negative test data to expose it.

Why is "Swapping the two indices of a 2D array — writing `grid[col][row]` instead of `grid[row][column]`." a common mistake in Data structures?

Why it happens: With counters named `i` and `j` there is nothing in the code to indicate which one means what, so the order becomes a matter of memory rather than of reading. How to avoid it: The convention is fixed: **row first, column second**. Use descriptive counter names — `row` and `col` rather than `i` and `j` — so `grid[col][row]` looks visibly wrong. Note that on a non-square grid the swap usually causes an out-of-range error, but on a square grid it silently returns the wrong cell. Source: 2D array access questions deliberately ask for both grid[1][2] and grid[2][1] to test whether the order is understood.

Why is "Placing a row-total accumulator outside the outer loop, or inside the inner loop, when totalling each row of a 2D array separately." a common mistake in Data structures?

Why it happens: There are three plausible-looking positions and only one is correct; students place the initialisation with the other setup statements at the top out of habit. How to avoid it: Reason from what should happen: the total must **reset once per row**, so `rowTotal ← 0` goes **inside the outer loop but before the inner loop**. Before the outer loop gives one grand total for the whole array; inside the inner loop resets it on every cell, leaving only the final value. Source: The placement carries its own mark in mark schemes for per-row processing questions.

Why is "Defining every field of a record as a String, rather than choosing the correct type for each." a common mistake in Data structures?

Why it happens: A String can hold anything, so it is the safe-feeling default — and in Python, where types are inferred, students rarely have to state a type at all. How to avoid it: Go field by field and apply 3.2.1's reasoning: a **price** needs decimals so it is Real; a **count** is whole so it is Integer; a **yes/no** has two states so it is Boolean; and an **ID or ISBN** that may start with 0 must be String. Mark schemes award marks for the correct type per field, so this is worth real marks. Source: AQA's own record example in 3.2.6 deliberately mixes String, Real and Integer to make the point.

Why is "Choosing an array to store several different attributes of one thing, such as a name, a price and a stock level." a common mistake in Data structures?

Why it happens: An array is the structure students meet first and feel most confident with, so it becomes the default answer whenever several values must be stored together. How to avoid it: Ask the two diagnostic questions: **are all the values the same data type?** and **do they describe one thing or many things?** Different types describing one thing means a **record**. If you also need many of them, use an **array of records** — that combination, not a plain array, is what stores a table of data. Source: Structure-choice questions award a mark for the choice and a mark for a justification that references the mixed data types.

AQA GCSE Computer Science (8525)

Data structures

0% Complete

Detailed Study Notes

Detailed notes on Programming for AQA GCSE Computer Science, covering key concepts, explanations, examples, and exam-focused revision points.

Data Structures — AQA GCSE Computer Science 8525 (3.2.6)

Two structures, and AQA is precise about the limits: arrays (only one- and two-dimensional are required) and records. An array stores many values of the same type under one name; a record groups values of different types describing one thing. Master traversal with a FOR loop, nested loops for 2D arrays, and the RECORD definition AQA gives in the specification, and this subtopic is fully covered.

At a glance

A data structure is an organised way of storing a collection of related data under one name.
An array stores multiple values of the same data type, accessed by an index (position number).
Only one- and two-dimensional arrays are required — nothing deeper.
Traverse a 1D array with a single FOR loop; traverse a 2D array with nested FOR loops.
A 2D array is a grid: grid[row][column]. The outer loop walks the rows, the inner loop the columns.
A record groups together items of different data types that describe one thing.
AQA's own record example: a Car with make, model, reg (String), price (Real) and noOfDoors (Integer).
Array = many of the SAME thing. Record = one thing with MANY properties.
An array of records combines both — the standard way to store a table of data.
Watch the index base: AQA questions may index from 0 or from 1, and will say which.

What you’ll learn

Mapped to the AQA GCSE 8525 syllabus (2027-2029).

Understand the concept of data structures.
Use arrays (or equivalent) in the design of solutions to simple problems — only one- and two-dimensional arrays are required.
Use records (or equivalent) in the design of solutions to simple problems.

What a data structure is — and why you need one

An organised way of storing a collection of related data under a single name.

A data structure is an organised way of storing a collection of related data items under one name.

The problem it solves

Suppose you must store the marks of 30 students. Without a data structure:

mark1 ← 65
mark2 ← 72
mark3 ← 48
… twenty-seven more …
mark30 ← 81

This is unusable:

30 separate variable names to declare and remember.
You cannot loop over them — there is no way to say "the next one".
Changing to 300 students means writing 270 more lines.
Every operation (find the highest, calculate the average) must be written out 30 times.

With an array:

marks ← [65, 72, 48, … , 81]

total ← 0
FOR i ← 0 TO 29
    total ← total + marks[i]
ENDFOR
average ← total / 30

Four lines handle any number of students. Change 29 to 299 and it works for 300. That is the entire point of a data structure: it lets a loop do the repetitive work.

The two structures you need

	Array	Record
Stores	Many values of the SAME data type	Several values of DIFFERENT data types
Accessed by	Index (position number)	Field name
Models	A list of similar things	One thing with several properties
Example	30 student marks	One student: name, age, tutor group, average

The one-line summary: an array is many of the same thing; a record is one thing with many properties.

AQA tip. The specification says arrays and records "or equivalent" — Python has no built-in array or record type, so lists and dictionaries (or classes) are accepted. The concepts are what is examined, not the language-specific name.

A data structure organises a collection of related data under one name.
Its real value is that a LOOP can process every item.
Array = many values of the SAME type, accessed by index.
Record = one thing with several properties of DIFFERENT types, accessed by field name.

See the full worked example for data structures →

One-dimensional arrays

A single list. Access by index, traverse with a FOR loop.

Creating and accessing

temps ← [18, 21, 19, 24, 22, 20, 17]

Each value is an element. Its position number is the index.

Index	0	1	2	3	4	5	6
Value	18	21	19	24	22	20	17

temps[0] is 18 — the first element
temps[3] is 24
temps[6] is 17 — the last element of a 7-element array

⚠️ Index base. Arrays here are zero-indexed: the first element is at index 0, so a 7-element array has indices 0 to 6. Some AQA questions index from 1 instead — the question will always make it clear, so check before you start.

The out-of-range error

temps[7] does not exist. Accessing it causes an out-of-range error and the program crashes. This is why search loops carry a bounds guard: WHILE i < LEN(temps) AND ….

Traversal — the pattern you must know

Traversal means visiting every element in turn. The tool is a count-controlled FOR loop:

total ← 0
FOR i ← 0 TO 6
    total ← total + temps[i]
ENDFOR
OUTPUT 'Average: ', total / 7

Better, using the array's length so the code survives a change of size:

FOR i ← 0 TO LEN(temps) - 1

Why LEN(temps) - 1? LEN gives the number of elements (7), but the last index is one less (6). This off-by-one is a classic error.

The four traversal patterns

Every array question is one of these four:

# 1. Running total
total ← 0
FOR i ← 0 TO LEN(a) - 1
    total ← total + a[i]
ENDFOR

# 2. Counting matches
count ← 0
FOR i ← 0 TO LEN(a) - 1
    IF a[i] > 20 THEN
        count ← count + 1
    ENDIF
ENDFOR

# 3. Finding the maximum
highest ← a[0]                  # start from the DATA, not from 0
FOR i ← 1 TO LEN(a) - 1
    IF a[i] > highest THEN
        highest ← a[i]
    ENDIF
ENDFOR

# 4. Searching (linear search — 3.1.3)
found ← False
i ← 0
WHILE i < LEN(a) AND found = False
    IF a[i] = target THEN
        found ← True
    ELSE
        i ← i + 1
    ENDIF
ENDWHILE

Note pattern 3. highest is initialised from a[0], not from 0. Starting at 0 breaks for an array of all-negative numbers — a deliberate exam trap.

AQA tip. Learn these four shapes as units. Almost every array question on Paper 1 is one of them, or two combined.

Element = a stored value; index = its position number.
Zero-indexed: a 7-element array has indices 0 to 6. Check what the question uses.
Accessing an index that does not exist causes an out-of-range error.
Traverse with FOR i ← 0 TO LEN(a) - 1 — note the minus one.
Four patterns: running total, counting, finding the maximum, searching.
Initialise a maximum from a[0], never from 0.

See the full worked example for data structures →

Two-dimensional arrays

A grid. Two indices, and nested loops to traverse it.

A 2D array stores data in a grid of rows and columns — a seating plan, a game board, a timetable, a spreadsheet.

scores ← [[12, 15, 9],
          [18, 11, 14],
          [7,  20, 16],
          [13, 8,  19]]

This is 4 rows × 3 columns. Access with two indices: scores[row][column].

The order of the two indices matters: scores[2][1] and scores[1][2] are different cells.

Traversing a 2D array — nested loops

total ← 0
FOR row ← 0 TO 3
    FOR col ← 0 TO 2
        total ← total + scores[row][col]
    ENDFOR
ENDFOR

The outer loop walks the rows; the inner loop walks the columns within each row. The inner loop completes fully for every single outer iteration (3.2.2), so this visits 4 × 3 = 12 cells.

Totalling each row separately

FOR row ← 0 TO 3
    rowTotal ← 0                      # RESET inside the outer loop
    FOR col ← 0 TO 2
        rowTotal ← rowTotal + scores[row][col]
    ENDFOR
    OUTPUT 'Row ', row, ' total: ', rowTotal
ENDFOR

The placement of rowTotal ← 0 is the whole question. It must be:

Inside the outer loop (so it resets for each new row), and
Before the inner loop (so it is not reset on every cell).

Put it before the outer loop and you get one grand total; put it inside the inner loop and it resets constantly, leaving only the last value.

AQA tip. Use meaningful loop counters — row and col rather than i and j. With two indices it is genuinely easy to write scores[col][row] by mistake, and descriptive names make that error visible.

A 2D array is a grid: scores[row][column] — row first, column second.
Traverse with nested FOR loops: outer for rows, inner for columns.
Total cells visited = rows × columns.
To total each row separately, reset the accumulator inside the outer loop but before the inner loop.
Use row and col as counter names to avoid swapping the indices.

See the full worked example for data structures →

Records

Group different data types describing one thing, accessed by field name.

A record groups together several related data items of possibly different data types, describing a single thing.

An array cannot do this — every element of an array must be the same type. A record can hold a String, a Real and an Integer side by side.

AQA's own example, from the specification

RECORD Car
    make       : String
    model      : String
    reg        : String
    price      : Real
    noOfDoors  : Integer
ENDRECORD

Each named item is a field. Notice the mixture: three Strings, a Real and an Integer, all describing one car.

Using a record

myCar.make      ← 'Toyota'
myCar.model     ← 'Yaris'
myCar.reg       ← 'AB21 CDE'
myCar.price     ← 12495.00
myCar.noOfDoors ← 5

OUTPUT myCar.make, ' ', myCar.model, ' — £', myCar.price

Fields are accessed by name using a dot: myCar.price. Compare this with an array, where you access by number: prices[3].

Why field names are better here. myCar.price says what it is. In an array you would have to remember that "index 3 is the price", which is fragile and unreadable.

Array vs record — choosing correctly

Situation	Use	Why
30 exam marks	Array	All the same type; you want to loop over them
One student's name, age and average	Record	Different types; they describe one person
Temperatures for each day of a week	Array	Same type, a list
One book's title, author, ISBN and price	Record	Different types, one book
100 books, each with those four fields	Array of records	Both — see below

Array of records — the powerful combination

RECORD Student
    name    : String
    age     : Integer
    average : Real
ENDRECORD

students : ARRAY[0:29] OF Student      # 30 Student records

students[0].name    ← 'Amina'
students[0].age     ← 15
students[0].average ← 78.5

# Now you can loop over all 30
FOR i ← 0 TO 29
    OUTPUT students[i].name, ' scored ', students[i].average
ENDFOR

This is how a table of data is stored, and it is exactly the structure behind a database table (3.7.1): the array is the table, each record is a row, and each field is a column.

AQA tip. In an exam, write a record definition using the specification's own layout — RECORD name, one field : Type per line, then ENDRECORD. Mark schemes credit the field names and the correct data type for each, so choose types carefully (a price is Real, a count is Integer, a reg is String).

A record groups related items of DIFFERENT data types describing one thing.
Each named item is a field, accessed with a dot: myCar.price.
AQA's example: RECORD Car with make/model/reg (String), price (Real), noOfDoors (Integer).
Array = many of the same; record = one thing with many properties.
An array of records stores a table of data — the structure behind a database table.

See the full worked example for data structures →

Choosing the right structure in an exam question

Ask: same type or different types? One thing or many things?

The decision routine

Are all the values the SAME data type?
- Yes → array
- No → record
Do the values describe ONE thing, or MANY similar things?
- One thing with several properties → record
- Many similar things → array
Both? (many things, each with several properties) → array of records
Is it a grid — rows and columns? → 2D array

Worked judgements

Requirement	Structure	Reason
Store the 12 monthly rainfall figures	1D array	12 values, all Real, a simple list
Store one employee's name, salary and start date	Record	Different types, one person
Store a noughts-and-crosses board	2D array	A 3 × 3 grid of the same type
Store 500 products, each with a name, price and stock level	Array of records	Many things, each with mixed-type properties
Store a class seating plan (6 rows × 5 seats)	2D array	A grid
Store the high scores of 10 players with their names	Array of records	Name (String) + score (Integer) per player

Justifying your choice for marks

A justification must reference the data, not repeat the definition:

✅ "A record, because the details are of different data types — the name is a String but the price is a Real — and an array requires every element to be the same type."
✅ "A 2D array, because the seating plan is a grid of rows and columns, and each seat holds the same type of value."
❌ "A record, because a record stores fields." (definition, not justification)

AQA tip. When a question says "design a data structure to store…", write the actual definition — the RECORD … ENDRECORD block or the array declaration — rather than describing it in prose. Marks are awarded for correct field names and correct data types, and prose rarely contains both.

Same type → array. Different types → record. Both → array of records.
Rows and columns → 2D array.
Justify by referring to the DATA (different types, a grid), not by defining the structure.
When asked to design a structure, write the actual definition, not a description.

See the full worked example for data structures →

Quick recap

A data structure organises a collection of related data under one name so a loop can process it.
An array stores many values of the SAME type, accessed by index; only 1D and 2D are required.
Arrays are typically zero-indexed, so an n-element array has indices 0 to n−1.
Traverse a 1D array with FOR i ← 0 TO LEN(a) - 1; the minus one prevents an out-of-range error.
A 2D array is a grid accessed as a[row][column] and traversed with nested loops.
To total each row separately, reset the accumulator inside the outer loop but before the inner loop.
A record groups DIFFERENT data types describing one thing, accessed by field name with a dot.
AQA's record example is a Car with make/model/reg (String), price (Real) and noOfDoors (Integer).
An array of records stores a table of data — many things, each with several properties.

Memorise this

Verbatim phrases and definitions Cambridge mark schemes credit.

A data structure is an organised way of storing a collection of related data under one name.
Array = many values of the SAME data type, accessed by index.
Record = several values of DIFFERENT data types describing ONE thing, accessed by field name.
Only ONE- and TWO-dimensional arrays are required.
A 2D array is accessed as array[row][column] — row first.
Traverse a 1D array: FOR i ← 0 TO LEN(a) - 1.
Traverse a 2D array: nested FOR loops, outer = rows, inner = columns.
RECORD Car / make : String / price : Real / noOfDoors : Integer / ENDRECORD (AQA's own example).

How it’s examined

3.2.6 is assessed on Paper 1 and appears in almost every algorithm-writing question, because arrays are how data gets into a program in the first place. Four shapes recur. (1) Recall, 1–2 marks: state what an array is, or the difference between an array and a record (AO1). (2) Read an element, 1–3 marks: state the value of a[3] or grid[2][1] from a printed array — check the index base and the row-then-column order (AO2). (3) Design a structure, 3–6 marks: write a RECORD … ENDRECORD definition for a given scenario, where marks go to the field names and the correct data type for each (AO2/AO3). (4) Traverse and process, 4–12 marks: write an algorithm that totals, counts, finds the maximum or searches an array, or uses nested loops on a 2D array — the biggest mark block (AO3). Two boundaries are worth knowing: only one- and two-dimensional arrays are required, and the specification says arrays and records 'or equivalent', so Python lists and dictionaries are accepted. The errors that cost most are the off-by-one in LEN(a) - 1, swapping row and column in a 2D access, and initialising a maximum-finder from 0 instead of from the first element.

Sources: AQA GCSE Computer Science 8525 specification (v1.3, 16 June 2025) — 3.2.6 Data structures; AQA GCSE Computer Science 8525 standard pseudo-code reference document; AQA GCSE Computer Science Paper 1 past papers, mark schemes and examiner reports. Last reviewed 2026-07-28.

Take this whole topic with you

Step-by-step worked examples — Data structures

Step-by-step solutions to past-paper-style questions on data structures, written exactly the way a tutor would explain them at the board.

Question type:

1Explain why an array is better than separate variables (3 marks)
Getting startedIdentify & classify• Paper 1 style — 3 marks (AO1/AO2)• array, explain, advantages
Question
A programmer needs to store the marks of 30 students. Explain why using an array is better than using 30 separate variables called mark1, mark2, mark3 and so on. (3 marks)
Step-by-step solution
1. Step 1
  The decisive advantage — a loop can process an array. With separate variables there is no way to say 'the next one', so every operation must be written out 30 times.
2. Step 2
  Less code, easier to maintain. Totalling an array takes three or four lines regardless of size; totalling 30 variables takes 30 statements.
3. Step 3
  Scales easily. Changing to 300 students needs no new variable declarations — the same loop works.
Answer
An array can be processed with a loop, because each element is identified by an index that the loop counter can supply — with 30 separate variables there is no way to refer to 'the next one', so every operation would have to be written out 30 times (1). This means far less code, which is easier to write, read and debug — calculating a total takes three or four lines whatever the size of the array (1). It also scales: increasing to 300 students requires no new variable declarations at all, whereas 270 extra variables and 270 extra statements would be needed otherwise (1). (3)
Examiner tip
The point that earns the first mark is the connection between the index and a loop counter — that is what makes iteration possible at all. Answers saying only 'it is tidier' or 'it uses one name' describe a cosmetic benefit rather than the functional one examiners are looking for.
2Read elements from an array (4 marks)
Getting startedIdentify & classify• Paper 1 style — 4 marks (AO2)• array, index, read
Question
The array temps holds [18, 21, 19, 24, 22, 20, 17] and is indexed from 0.

(a) State the value of temps[0]. (b) State the value of temps[4]. (c) State the index of the value 24. (d) State what happens if the program tries to access temps[7]. (4 marks)
Step-by-step solution
1. Step 1
  (a) Index 0 is the first element, so temps[0] is 18.
2. Step 2
  (b) Count from 0: index 0 = 18, 1 = 21, 2 = 19, 3 = 24, 4 = 22.
3. Step 3
  (c) 24 is the fourth element, but because indexing starts at 0 its index is 3.
4. Step 4
  (d) The array has 7 elements with valid indices 0 to 6, so index 7 does not exist. Accessing it causes an out-of-range error and the program crashes.
Answer
(a) 18 (1) (b) 22 (1) (c) 3 (1) (d) The array has 7 elements with valid indices 0 to 6, so temps[7] does not exist — the program would produce an out-of-range error and crash (1). (4)
Examiner tip
Everything here turns on zero-indexing: an n-element array has indices 0 to n−1, so the last valid index is one less than the length. This is exactly why array traversal uses FOR i ← 0 TO LEN(a) - 1, and why a search loop needs a bounds guard.
3Distinguish an array from a record (3 marks)
Getting startedIdentify & classify• Paper 1 style — 3 marks (AO1)• array, record, compare
Question
Explain the difference between an array and a record, giving one example of data suited to each. (3 marks)
Step-by-step solution
1. Step 1
  Array: stores many values of the same data type, accessed by an index (a position number).
2. Step 2
  Record: groups several values of different data types that all describe one thing, accessed by field name.
3. Step 3
  Examples: an array suits 30 exam marks (all integers); a record suits one student's name (String), age (Integer) and average (Real).
Answer
An array stores multiple values that are all of the same data type, each accessed by its index (position number) — for example the 30 exam marks of a class, which are all integers (1). A record groups together several values of different data types that describe a single thing, each accessed by its field name — for example one student's name (String), age (Integer) and average mark (Real) (1). The essential difference is that an array holds many of the same thing, whereas a record holds one thing with several properties (1). (3)
Examiner tip
The one-line summary in the final mark — 'many of the same thing' versus 'one thing with many properties' — is the cleanest way to hold the distinction, and it makes scenario questions almost automatic. Note the second contrast too: arrays are accessed by number, records by name.
4Traverse a 1D array to find a total and a maximum (5 marks)
Building confidenceMulti-step problem• Paper 1 style — 5 marks (AO3)• array, traversal, maximum, total
Question
The array marks holds the test scores of a class. Write an algorithm using pseudo-code that outputs the average mark and the highest mark. (5 marks)
Step-by-step solution
1. Step 1
  Initialise both accumulators before the loop. total ← 0 for the sum, and highest ← marks[0] — starting the maximum from the first data value, not from 0.
2. Step 2
  Why not highest ← 0? If every mark were negative, 0 would never be beaten and the answer would be wrong. Initialising from marks[0] is always safe.
3. Step 3
  Traverse with a FOR loop running from 0 to LEN(marks) - 1 — the minus one because the last index is one less than the length.
4. Step 4
  Inside the loop: add to the total, and update highest if the current element beats it.
5. Step 5
  Calculate and output after the loop. Use real division for the average, since an average will usually have a decimal part.
Answer
total ← 0 highest ← marks[0] FOR i ← 0 TO LEN(marks) - 1 total ← total + marks[i] IF marks[i] > highest THEN highest ← marks[i] ENDIF ENDFOR average ← total / LEN(marks) OUTPUT 'Average mark: ', average OUTPUT 'Highest mark: ', highest

Marks: total initialised to 0 before the loop (1); highest initialised from marks[0] rather than 0 (1); correct loop bounds using LEN(marks) - 1 (1); running total and maximum comparison both correct inside the loop (1); average calculated with real division and both outputs placed after the loop (1). (5)
Examiner tip
Three marks here are lost routinely. Initialising highest ← 0 breaks for all-negative data. Writing FOR i ← 0 TO LEN(marks) runs one iteration too many and causes an out-of-range error. And placing the OUTPUT inside the loop prints a running answer for every element instead of one final result.
5Traverse a 2D array with nested loops (5 marks)
Building confidenceMulti-step problem• Paper 1 style — 5 marks (AO2/AO3)• 2d-array, nested-loops, traversal
Question
The 2D array scores has 4 rows and 3 columns, indexed from 0.

(a) State the value referred to by scores[2][1] if row 2 holds [7, 20, 16]. (b) Write an algorithm that outputs the total for each row separately. (c) State how many cells the algorithm visits in total. (5 marks)
Step-by-step solution
1. Step 1
  (a) Row first, then column. scores[2][1] is row 2, column 1 — the second value in [7, 20, 16], which is 20.
2. Step 2
  (b) Nested loops. The outer loop walks the rows (0 to 3); the inner loop walks the columns within each row (0 to 2).
3. Step 3
  The critical placement. rowTotal ← 0 must go inside the outer loop but before the inner loop, so it resets once per row.
4. Step 4
  Output inside the outer loop, after the inner loop — so one total is printed per row.
5. Step 5
  (c) The inner loop runs fully for every outer iteration: 4 × 3 = 12 cells.
  $4 \times 3 = 12$
Answer
(a) scores[2][1] is 20 — row 2, then column 1, which is the second value in that row (1).

(b)

FOR row ← 0 TO 3 rowTotal ← 0 FOR col ← 0 TO 2 rowTotal ← rowTotal + scores[row][col] ENDFOR OUTPUT 'Row ', row, ' total: ', rowTotal ENDFOR

Marks: correct nested loop structure with the right bounds (1); rowTotal reset inside the outer loop but before the inner loop (1); correct accumulation using scores[row][col] (1).

(c) 12 cells — the inner loop runs completely for every iteration of the outer loop, so 4 × 3 = 12 (1). (5)
Examiner tip
The placement of rowTotal ← 0 is the whole question. Before the outer loop it gives one grand total across the entire array; inside the inner loop it resets on every cell, leaving only the last value. Only between the two loops does it reset once per row. Note also that scores[2][1] and scores[1][2] are different cells — the order of indices always matters.
6Write a record definition for a scenario (5 marks)
Building confidenceWord problem• Paper 1 style — 5 marks (AO2/AO3)• record, fields, data-types
Question
A library needs to store the following about each book: title, author, ISBN (a 13-digit code that may begin with 0), the price paid, the number of copies held, and whether it is currently on loan.

Write a suitable record definition using pseudo-code. (5 marks)
Step-by-step solution
1. Step 1
  Use AQA's layout: RECORD and a name, then one field : Type per line, then ENDRECORD.
2. Step 2
  Title and author → String. Both are sequences of characters.
3. Step 3
  ISBN → String, not Integer. It may begin with 0, and a leading zero would be lost if stored as a number. No arithmetic is ever performed on an ISBN.
4. Step 4
  Price → Real (it needs pence). Number of copies → Integer (a count is always whole).
5. Step 5
  On loan → Boolean, since there are only two possible states.
Answer
RECORD Book title : String author : String isbn : String price : Real copies : Integer onLoan : Boolean ENDRECORD

Marks: correct RECORD … ENDRECORD structure with meaningful field names (1); title and author as String (1); isbn as String rather than Integer (1); price as Real and copies as Integer (1); onLoan as Boolean (1). (5)
Examiner tip
The ISBN is the deliberate trap and is worth its own mark: it looks numeric but must be a String, because a leading zero would be lost and no arithmetic is ever done on it — the same reasoning as phone numbers and postcodes in 3.2.1. Note that a record is exactly the right structure here because the six items are of four different data types, which an array could not hold.
7Choose and justify data structures for a system (6 marks)
StretchWord problem• Paper 1 style — 6 marks (AO3)• choose, justify, array, record, 2d-array
Question
A school system must store:

(a) the 12 monthly attendance percentages for the whole school (b) one teacher's name, staff number, salary and whether they are full-time (c) a seating plan for a classroom with 6 rows of 5 seats

State the most suitable data structure for each and justify your choice. (6 marks)
Step-by-step solution
1. Step 1
  (a) Twelve values, all of the same type (Real percentages), forming a simple list → a 1D array.
2. Step 2
  Justify (a): all the values are the same data type and can be processed with a single loop, which is exactly what an array is for.
3. Step 3
  (b) Four values of different types describing one person → a record.
4. Step 4
  Justify (b): name is a String, salary a Real, full-time a Boolean — an array cannot hold mixed types, so a record is required.
5. Step 5
  (c) A grid of rows and columns → a 2D array.
6. Step 6
  Justify (c): the data has two dimensions, so each seat is naturally identified by seats[row][column], matching the physical layout.
Answer
(a) A one-dimensional array (1). All twelve values are the same data type (a Real percentage) and form a simple list, so they can be stored under one name and processed with a single loop — for example to find the highest or average month (1).

(b) A record (1). The four items are of different data types — the name is a String, the staff number a String, the salary a Real and full-time status a Boolean — and an array requires every element to be the same type, so only a record can group them (1).

(c) A two-dimensional array (1). The seating plan is a grid of rows and columns, so each seat is naturally identified by two indices as seats[row][column], which matches the physical layout of the classroom and allows traversal with nested loops (1). (6)
Examiner tip
Each part carries one mark for the structure and one for the justification, and the justification must reference the data — 'the values are different data types', 'the data forms a grid' — rather than restating the definition. Note the staff number is best stored as a String for the same leading-zero reason as an ISBN, and mentioning that would be credited.
8Use an array of records (6 marks)
StretchMulti-step problem• Paper 1 style — 6 marks (AO3)• array-of-records, record, traversal
Question
A shop stores details of 100 products. Each product has a name, a price and a stock level.

(a) Define a suitable record and declare an array to hold 100 of them. (b) Write an algorithm that outputs the name of every product whose stock level is below 5. (6 marks)
Step-by-step solution
1. Step 1
  (a) The record holds one product's three properties, with types: name → String, price → Real, stock → Integer.
2. Step 2
  The array holds 100 of these records: products : ARRAY[0:99] OF Product. Indices 0 to 99 give exactly 100 elements.
3. Step 3
  (b) Traverse the array with a FOR loop from 0 to 99.
4. Step 4
  Access a field of an element by combining both notations: products[i].stock — index into the array first, then select the field.
5. Step 5
  Test the condition < 5, since 'below 5' excludes 5 itself.
6. Step 6
  Output the name field of any matching record.
Answer
(a)

RECORD Product name : String price : Real stock : Integer ENDRECORD products : ARRAY[0:99] OF Product

Marks: correct record definition with sensible field names (1); correct data type for each field (1); array declared to hold 100 records (1).

(b)

FOR i ← 0 TO 99 IF products[i].stock < 5 THEN OUTPUT products[i].name ENDIF ENDFOR

Marks: correct traversal of the array (1); correct combined access products[i].stock (1); correct condition < 5 and output of the name field (1). (6)
Examiner tip
The combined notation products[i].stock is the key skill: index into the array first, then select the field with a dot. Note the boundary — 'below 5' means < 5, so a stock level of exactly 5 is not reported. This structure, an array of records, is exactly how a database table is represented in a program: the array is the table, each record a row, each field a column (3.7.1).
9Find and fix the array errors (6 marks)
StretchIdentify & classify• Paper 1 style — 6 marks (AO3)• debugging, array, off-by-one, identify-error
Question
The algorithm below should find the largest value in the array data, which holds 10 elements indexed 0 to 9. It contains three errors. Identify each, explain its effect, and write a corrected version. (6 marks)

1 largest ← 0 2 FOR i ← 0 TO 10 3 IF data[i] > largest THEN 4 largest ← data[i] 5 ENDIF 6 ENDFOR 7 OUTPUT largest
Step-by-step solution
1. Step 1
  Error 1 — line 1. largest ← 0 fails when every value in the array is negative, because no negative number is greater than 0, so the algorithm wrongly reports 0.
2. Step 2
  Fix 1. Initialise from the data itself: largest ← data[0]. That value is guaranteed to be in the array.
3. Step 3
  Error 2 — line 2. FOR i ← 0 TO 10 runs 11 times (0 to 10 inclusive), so on the final iteration it accesses data[10], which does not exist in a 10-element array indexed 0 to 9.
4. Step 4
  Fix 2. Use FOR i ← 0 TO 9, or better FOR i ← 0 TO LEN(data) - 1 so the code survives a change of size.
5. Step 5
  Error 3 — the loop starts at 0 unnecessarily once largest is initialised from data[0]. Comparing data[0] with itself is harmless but wasteful; starting at 1 is the standard form.
6. Step 6
  Write the corrected version combining all three fixes.
Answer
Error 1 — line 1: largest ← 0. If every element of the array is negative, none of them will ever be greater than 0, so largest stays at 0 and the algorithm reports a value that is not even in the array (1). Fix: initialise from the data with largest ← data[0] (1).

Error 2 — line 2: FOR i ← 0 TO 10. This runs 11 iterations (0 to 10 inclusive), so the final one accesses data[10] — which does not exist in a 10-element array indexed 0 to 9 — causing an out-of-range error and crashing the program (1). Fix: FOR i ← 0 TO LEN(data) - 1 (1).

Error 3 — the loop starts at 0. Once largest has been initialised from data[0], comparing element 0 with itself is redundant; the traversal should begin at index 1 (1).

Corrected version:

largest ← data[0] FOR i ← 1 TO LEN(data) - 1 IF data[i] > largest THEN largest ← data[i] ENDIF ENDFOR OUTPUT largest

(1)
Examiner tip
Errors 1 and 2 are the two classic array faults and each carries a mark for identification plus one for the fix. Error 1 is the more instructive: the program runs without crashing and simply returns a wrong answer — a logic error that only reveals itself with all-negative data, which is precisely why choosing good test data matters (3.2.11). Error 2 is an off-by-one that crashes and is therefore easier to spot.

Model Answers — Data structures

High-scoring sample answers for data structures on the AQA GCSE 8525 paper, with examiner-style notes mapping each response to the mark scheme and assessment objectives.

Question 1
Paper 1 style — AO12 marks
Define the term array. (2 marks)
Model answer
An array is a data structure that stores multiple values of the same data type under a single name (1), where each value is accessed using its index — the position number of that element within the array (1).
Why this scores
Both halves are needed: 'same data type' distinguishes an array from a record, and 'accessed by index' distinguishes it from a record's field names. Answers giving only 'a list of values' typically score 1.
Question 2
Paper 1 style — AO11 mark
State the array dimensions that are required by the AQA GCSE Computer Science specification. (1 mark)
Model answer
Only one-dimensional and two-dimensional arrays are required (1).
Why this scores
This is an explicit boundary in the specification's additional information column. You will never be asked to work with a three-dimensional array, so there is no need to revise beyond a grid.
Question 3
Paper 1 style — AO12 marks
State what is meant by a field in a record, and how a field is accessed. (2 marks)
Model answer
A field is one of the named data items within a record, each of which can have its own data type (1). A field is accessed using the record name followed by a dot and the field name — for example myCar.price (1).
Why this scores
The contrast with arrays is worth stating: a record's items are accessed by name, whereas an array's are accessed by index number. That is why records are used when the items have different meanings, and arrays when they are interchangeable list entries.
Question 4
Paper 1 style — AO24 marks
Trace the algorithm below and state what is output. The array values holds [4, 11, 7, 2, 9]. (4 marks)
```
count ← 0
FOR i ← 0 TO 4
    IF values[i] > 5 THEN
        count ← count + 1
    ENDIF
ENDFOR
OUTPUT count
```
Model answer

i values[i] > 5 ? count
— — — 0
0 4 False
1 11 True 1
2 7 True 2
3 2 False
4 9 True 3

OUTPUT: 3

The algorithm counts how many values in the array are greater than 5.

Marks: correct values[i] for each index (1); all five condition results correct (1); correct count progression (1); correct output of 3 (1).
Why this scores
The loop runs 0 to 4, which is five iterations for a five-element array — matching the zero-indexing. A one-sentence statement of purpose ('it counts how many values are greater than 5') is what a follow-up 'determine the purpose' question would require, rather than a line-by-line narration.
Question 5
Paper 1 style — AO24 marks
A 2D array grid holds:
```
row 0:  [5,  8,  2]
row 1:  [9,  1,  7]
row 2:  [3,  6,  4]
```
It is indexed from 0.

(a) State the value of grid[1][2]. (b) State the value of grid[2][0]. (c) Explain why grid[1][2] and grid[2][1] give different values. (4 marks)
Model answer
(a) grid[1][2] is row 1, column 2 → 7 (1) (b) grid[2][0] is row 2, column 0 → 3 (1) (c) The two indices are not interchangeable: the first index selects the row and the second selects the column (1). So grid[1][2] is the third value in the second row, which is 7, whereas grid[2][1] is the second value in the third row, which is 6 — they refer to entirely different cells (1).
Why this scores
The row-then-column convention is fixed and is a frequent source of lost marks. Using descriptive loop counters such as row and col rather than i and j makes an accidental swap far easier to spot when writing your own code.
Question 6
Paper 1 style — AO24 marks
A program must store the details of one car: its make, model, registration, price and number of doors. Explain why a record is more suitable than an array. (4 marks)
Model answer
The five items are of different data types — make, model and registration are Strings, the price is a Real and the number of doors is an Integer (1). An array requires every element to be the same data type, so it could not store this mixture (1).

A record also allows each item to be accessed by a meaningful field name such as myCar.price, which makes the program far easier to read and less error-prone than remembering that 'index 3 is the price' (1). Finally, the five items all describe one single thing — one car — which is exactly what a record is designed to model, whereas an array models a list of many similar things (1).
Why this scores
This is AQA's own record example from the specification, so the field names and types are worth memorising exactly. Three distinct arguments are available — mixed data types, named access, and modelling one entity — and any three developed points reach full marks.
Question 7
Paper 1 style — AO38 marks
The 2D array sales has 12 rows (months) and 4 columns (regions), indexed from 0. Write an algorithm using pseudo-code that finds and outputs the highest single sales figure together with the month and region in which it occurred. (8 marks)
Model answer
highest ← sales[0][0] bestMonth ← 0 bestRegion ← 0 FOR row ← 0 TO 11 FOR col ← 0 TO 3 IF sales[row][col] > highest THEN highest ← sales[row][col] bestMonth ← row bestRegion ← col ENDIF ENDFOR ENDFOR OUTPUT 'Highest sales: ', highest OUTPUT 'Month: ', bestMonth OUTPUT 'Region: ', bestRegion

Marks: highest initialised from sales[0][0] rather than 0 (1); both position variables initialised (1); outer loop covering all 12 rows (1); inner loop covering all 4 columns (1); correct comparison sales[row][col] > highest (1); highest updated when a larger value is found (1); both position variables updated at the same time inside the IF (1); all three outputs placed after the loops (1). (8)
Why this scores
Two things separate a full-mark answer. First, bestMonth and bestRegion must be updated inside the same IF as highest — updating them elsewhere records the wrong position. Second, highest must start from sales[0][0], not 0, so the algorithm still works if all figures are negative. Note the algorithm visits 12 × 4 = 48 cells.
Question 8
Paper 1 style — AO38 marks
A club stores 50 members using an array of records. Each record has name (String), memberID (String) and feePaid (Boolean).

Write an algorithm that counts how many members have not paid, and outputs their names. Then explain why an array of records is the appropriate structure here. (8 marks)
Model answer
RECORD Member name : String memberID : String feePaid : Boolean ENDRECORD members : ARRAY[0:49] OF Member unpaidCount ← 0 FOR i ← 0 TO 49 IF NOT members[i].feePaid THEN unpaidCount ← unpaidCount + 1 OUTPUT members[i].name ENDIF ENDFOR OUTPUT 'Members who have not paid: ', unpaidCount

Marks: unpaidCount initialised to 0 before the loop (1); correct traversal of all 50 records (1); correct combined access members[i].feePaid (1); correct use of NOT on the Boolean (1); counter incremented and name output for each unpaid member (1); total output placed after the loop (1).

Why an array of records is appropriate. Each member's details are of different data types — two Strings and a Boolean — so a plain array could not hold them, and a record is needed to group them (1). But there are 50 members, all with the same structure, so the records must themselves be stored in an array in order to be processed with a single loop rather than being written out 50 times (1). (8)
Why this scores
The justification carries two of the eight marks and needs both halves: the record handles the mixed data types within one member, and the array handles the repetition across many members. Note IF NOT members[i].feePaid is cleaner than IF members[i].feePaid = False — a Boolean can be tested directly.
Question 9
Paper 1 style — AO1/AO36 marks
Explain what is meant by a data structure, and discuss why data structures are essential when writing programs that process large amounts of data. (6 marks)
Model answer
Definition. A data structure is an organised way of storing a collection of related data items under a single name, so that they can be accessed and processed systematically (1).

Why they are essential — iteration. The decisive advantage is that a data structure allows a loop to process every item, because each element can be identified by an index that the loop counter supplies (1). Without one, a programmer would need a separate variable for every value, and there would be no way to refer to 'the next one' — so every operation would have to be written out once per item (1).

Scalability. A program using an array to total 30 values needs the same three or four lines to total 30,000; a program using separate variables would need 30,000 declarations and 30,000 statements (1). This means the code is far shorter, easier to read and easier to debug, and can be changed to handle a different amount of data without being rewritten (1).

Modelling real data. Data structures also let a program mirror the real-world shape of its data: a record groups the different attributes of one thing, a 2D array represents a genuine grid such as a seating plan or game board, and an array of records represents a table — which makes the program easier to understand and maintain (1). (6)
Why this scores
The strongest single point, and the one that should lead the answer, is the link between indexing and iteration — that is what makes data structures functionally necessary rather than merely convenient. The final point about modelling real-world shape is the discriminator for the top band, since it goes beyond efficiency to design quality.

i	values[i]	> 5 ?	count
—	—	—	0
0	4	False
1	11	True	1
2	7	True	2
3	2	False
4	9	True	3

Key Definitions and Keywords — Data structures

Definitions to memorise and the exact keywords mark schemes credit for data structures answers — sharpened from recent examiner reports for the 2026 AQA GCSE 8525 sitting.

Data structure
Examiner keyword
An organised way of storing a collection of related data items under a single name, so that they can be accessed and processed systematically — usually with a loop.
Related: Array, Record
Array
Examiner keyword
A data structure storing multiple values of the same data type under one name, each accessed by its index. Only one- and two-dimensional arrays are required by the specification.
Example
temps ← [18, 21, 19, 24] — temps[2] is 19.
Related: Element, Index, Record
Element
Examiner keyword
A single value stored within an array.
Related: Array, Index
Index (subscript)
Examiner keyword
The position number identifying an element within an array. Arrays are usually zero-indexed, so an n-element array has indices 0 to n−1.
Example
In a 7-element array the valid indices are 0 to 6.
Related: Array, Out of range error
One-dimensional array
Examiner keyword
A simple list of elements accessed by a single index. Traversed with one FOR loop.
Example
FOR i ← 0 TO LEN(a) - 1
Related: Two dimensional array, Traversal
Two-dimensional array
Examiner keyword
A grid of elements accessed by two indices, written array[row][column]. Traversed with nested FOR loops — the outer for rows, the inner for columns.
Example
scores[2][1] is row 2, column 1.
Related: One dimensional array, Nested iteration
Traversal
Examiner keyword
Visiting every element of a data structure in turn, normally with a count-controlled FOR loop.
Example
FOR i ← 0 TO LEN(marks) - 1
Related: Array, Iteration
Out-of-range error
Examiner keyword
The error caused by accessing an index that does not exist in the array. Prevented by correct loop bounds and by a bounds guard in search conditions.
Example
Accessing temps[7] in a 7-element array indexed 0 to 6.
Related: Index (subscript), Off by one error
Record
Examiner keyword
A data structure grouping several related data items of possibly different data types that together describe one thing. Each item is a named field.
Example
RECORD Car / make : String / price : Real / noOfDoors : Integer / ENDRECORD
Related: Field, Array
Field
Examiner keyword
One of the named data items within a record, each of which may have its own data type. Accessed with a dot: myCar.price.
Related: Record
Array of records
Examiner keyword
An array whose elements are records — the standard way to store a table of data where there are many things, each with several properties. Accessed as array[index].field.
Example
products[i].stock
Related: Array, Record
LEN (length)
Examiner keyword
An operation returning the number of elements in an array. The last valid index is LEN − 1, which is why traversal runs to LEN(a) - 1.
Example
FOR i ← 0 TO LEN(marks) - 1
Related: Index (subscript), Traversal
Accumulator
A variable building up a running total or count while traversing a structure. Must be initialised before the loop — and, when totalling each row of a 2D array, reset inside the outer loop.
Example
rowTotal ← 0 placed inside the outer loop but before the inner loop.
Related: Traversal, Nested iteration
Bounds guard
A condition preventing an array being accessed beyond its last element, typically the first half of a compound loop condition in a search.
Example
WHILE i < LEN(items) AND found = False
Related: Out of range error, Compound condition
Or equivalent
The specification's phrase acknowledging that supported languages implement arrays and records differently — Python uses lists and dictionaries or classes. The concepts are assessed, not the language-specific names.
Related: Array, Record

Common Mistakes and Misconceptions — Data structures

The traps other students keep falling into on data structures questions — taken from recent AQA GCSE 8525 examiner reports and mark schemes — and how to avoid them.

✕Writing FOR i ← 0 TO LEN(a) instead of FOR i ← 0 TO LEN(a) - 1.
Off-by-one loop bounds are one of the two standard faults used in array error-identification questions on Paper 1.
Why it happens
LEN gives the number of elements, which feels like the natural upper limit — the gap between 'how many there are' and 'what the last index is' only exists because counting starts at 0.
How to avoid it
Hold the relationship explicitly: an array of n elements has indices 0 to n−1, so the last index is always one less than the length. Sanity-check with a small case — a 3-element array has indices 0, 1, 2. Getting this wrong causes an out-of-range error on the final iteration and crashes the program.
✕Initialising a maximum-finder with largest ← 0 instead of largest ← a[0].
This is a logic error that produces no crash and no error message, which is precisely why examiners set all-negative test data to expose it.
Why it happens
Zero feels like a natural neutral starting point, and with the positive test data used in most classroom examples the algorithm produces correct answers — so the flaw never surfaces.
How to avoid it
Initialise from the data itself: largest ← a[0], then start the loop at index 1. If every value in the array were negative, nothing would ever beat 0 and the algorithm would report a value that is not even in the array. The mirror error applies to minimum-finders initialised to 0.
✕Swapping the two indices of a 2D array — writing grid[col][row] instead of grid[row][column].
2D array access questions deliberately ask for both grid[1][2] and grid[2][1] to test whether the order is understood.
Why it happens
With counters named i and j there is nothing in the code to indicate which one means what, so the order becomes a matter of memory rather than of reading.
How to avoid it
The convention is fixed: row first, column second. Use descriptive counter names — row and col rather than i and j — so grid[col][row] looks visibly wrong. Note that on a non-square grid the swap usually causes an out-of-range error, but on a square grid it silently returns the wrong cell.
✕Placing a row-total accumulator outside the outer loop, or inside the inner loop, when totalling each row of a 2D array separately.
The placement carries its own mark in mark schemes for per-row processing questions.
Why it happens
There are three plausible-looking positions and only one is correct; students place the initialisation with the other setup statements at the top out of habit.
How to avoid it
Reason from what should happen: the total must reset once per row, so rowTotal ← 0 goes inside the outer loop but before the inner loop. Before the outer loop gives one grand total for the whole array; inside the inner loop resets it on every cell, leaving only the final value.
✕Defining every field of a record as a String, rather than choosing the correct type for each.
AQA's own record example in 3.2.6 deliberately mixes String, Real and Integer to make the point.
Why it happens
A String can hold anything, so it is the safe-feeling default — and in Python, where types are inferred, students rarely have to state a type at all.
How to avoid it
Go field by field and apply 3.2.1's reasoning: a price needs decimals so it is Real; a count is whole so it is Integer; a yes/no has two states so it is Boolean; and an ID or ISBN that may start with 0 must be String. Mark schemes award marks for the correct type per field, so this is worth real marks.
✕Choosing an array to store several different attributes of one thing, such as a name, a price and a stock level.
Structure-choice questions award a mark for the choice and a mark for a justification that references the mixed data types.
Why it happens
An array is the structure students meet first and feel most confident with, so it becomes the default answer whenever several values must be stored together.
How to avoid it
Ask the two diagnostic questions: are all the values the same data type? and do they describe one thing or many things? Different types describing one thing means a record. If you also need many of them, use an array of records — that combination, not a plain array, is what stores a table of data.

Data Structures — AQA GCSE Computer Science 8525 (3.2.6)

Array

Record

Stores

Many values of the SAME data type

Several values of DIFFERENT data types

Accessed by

Index (position number)

Field name

Models

A list of similar things

One thing with several properties

Example

30 student marks

One student: name, age, tutor group, average

Index

Value

# 1. Running total total ← 0 FOR i ← 0 TO LEN(a) - 1 total ← total + a[i] ENDFOR # 2. Counting matches count ← 0 FOR i ← 0 TO LEN(a) - 1 IF a[i] > 20 THEN count ← count + 1 ENDIF ENDFOR # 3. Finding the maximum highest ← a[0] # start from the DATA, not from 0 FOR i ← 1 TO LEN(a) - 1 IF a[i] > highest THEN highest ← a[i] ENDIF ENDFOR # 4. Searching (linear search — 3.1.3) found ← False i ← 0 WHILE i < LEN(a) AND found = False IF a[i] = target THEN found ← True ELSE i ← i + 1 ENDIF ENDWHILE

FOR row ← 0 TO 3 rowTotal ← 0 # RESET inside the outer loop FOR col ← 0 TO 2 rowTotal ← rowTotal + scores[row][col] ENDFOR OUTPUT 'Row ', row, ' total: ', rowTotal ENDFOR

myCar.make ← 'Toyota' myCar.model ← 'Yaris' myCar.reg ← 'AB21 CDE' myCar.price ← 12495.00 myCar.noOfDoors ← 5 OUTPUT myCar.make, ' ', myCar.model, ' — £', myCar.price

Situation

Use

Why

30 exam marks

Array

All the same type; you want to loop over them

One student's name, age and average

Record

Different types; they describe one person

Temperatures for each day of a week

Array

Same type, a list

One book's title, author, ISBN and price

Record

Different types, one book

100 books, each with those four fields

Array of records

Both — see below

RECORD Student name : String age : Integer average : Real ENDRECORD students : ARRAY[0:29] OF Student # 30 Student records students[0].name ← 'Amina' students[0].age ← 15 students[0].average ← 78.5 # Now you can loop over all 30 FOR i ← 0 TO 29 OUTPUT students[i].name, ' scored ', students[i].average ENDFOR

Requirement

Structure

Reason

Store the 12 monthly rainfall figures

1D array

12 values, all Real, a simple list

Store one employee's name, salary and start date

Record

Different types, one person

Store a noughts-and-crosses board

2D array

A 3 × 3 grid of the same type

Store 500 products, each with a name, price and stock level

Array of records

Many things, each with mixed-type properties

Store a class seating plan (6 rows × 5 seats)

2D array

A grid

Store the high scores of 10 players with their names

Array of records

Name (String) + score (Integer) per player

total ← 0 highest ← marks[0] FOR i ← 0 TO LEN(marks) - 1 total ← total + marks[i] IF marks[i] > highest THEN highest ← marks[i] ENDIF ENDFOR average ← total / LEN(marks) OUTPUT 'Average mark: ', average OUTPUT 'Highest mark: ', highest

i	values[i]	> 5 ?	count
—	—	—	0
0	4	False
1	11	True	1
2	7	True	2
3	2	False
4	9	True	3

values[i]

> 5 ?

count

—

False

True

False

True

highest ← sales[0][0] bestMonth ← 0 bestRegion ← 0 FOR row ← 0 TO 11 FOR col ← 0 TO 3 IF sales[row][col] > highest THEN highest ← sales[row][col] bestMonth ← row bestRegion ← col ENDIF ENDFOR ENDFOR OUTPUT 'Highest sales: ', highest OUTPUT 'Month: ', bestMonth OUTPUT 'Region: ', bestRegion

RECORD Member name : String memberID : String feePaid : Boolean ENDRECORD members : ARRAY[0:49] OF Member unpaidCount ← 0 FOR i ← 0 TO 49 IF NOT members[i].feePaid THEN unpaidCount ← unpaidCount + 1 OUTPUT members[i].name ENDIF ENDFOR OUTPUT 'Members who have not paid: ', unpaidCount

Data structures

Detailed Study Notes

At a glance

What you’ll learn

What a data structure is — and why you need one

The problem it solves

The two structures you need

One-dimensional arrays

Creating and accessing

The out-of-range error

Traversal — the pattern you must know

The four traversal patterns

Two-dimensional arrays

Traversing a 2D array — nested loops

Totalling each row separately

Records

AQA's own example, from the specification

Using a record

Array vs record — choosing correctly

Array of records — the powerful combination

Choosing the right structure in an exam question

The decision routine

Worked judgements

Justifying your choice for marks

Quick recap

Memorise this

How it’s examined

Take this whole topic with you

1Explain why an array is better than separate variables (3 marks)

2Read elements from an array (4 marks)

3Distinguish an array from a record (3 marks)

4Traverse a 1D array to find a total and a maximum (5 marks)

5Traverse a 2D array with nested loops (5 marks)

6Write a record definition for a scenario (5 marks)

7Choose and justify data structures for a system (6 marks)

8Use an array of records (6 marks)

9Find and fix the array errors (6 marks)

Data structure

Array

Element

Index (subscript)

One-dimensional array

Two-dimensional array

Traversal

Out-of-range error

Record

Field

Array of records

LEN (length)

Accumulator

Bounds guard

Or equivalent

✕Writing FOR i ← 0 TO LEN(a) instead of FOR i ← 0 TO LEN(a) - 1.

✕Initialising a maximum-finder with largest ← 0 instead of largest ← a[0].

✕Swapping the two indices of a 2D array — writing grid[col][row] instead of grid[row][column].

✕Placing a row-total accumulator outside the outer loop, or inside the inner loop, when totalling each row of a 2D array separately.

✕Defining every field of a record as a String, rather than choosing the correct type for each.

✕Choosing an array to store several different attributes of one thing, such as a name, a price and a stock level.

Data structures

Detailed Study Notes

At a glance

What you’ll learn

What a data structure is — and why you need one

The problem it solves

The two structures you need

One-dimensional arrays

Creating and accessing

The out-of-range error

Traversal — the pattern you must know

The four traversal patterns

Two-dimensional arrays

Traversing a 2D array — nested loops

Totalling each row separately

Records

AQA's own example, from the specification

Using a record

Array vs record — choosing correctly

Array of records — the powerful combination

Choosing the right structure in an exam question

The decision routine

✕Writing `FOR i ← 0 TO LEN(a)` instead of `FOR i ← 0 TO LEN(a) - 1`.

✕Initialising a maximum-finder with `largest ← 0` instead of `largest ← a[0]`.

✕Swapping the two indices of a 2D array — writing `grid[col][row]` instead of `grid[row][column]`.