Arrays and Abstract Data Types

An array is a data structure that stores a fixed number of elements of the same data type in contiguous memory locations. Each element is accessed by its index — an integer that specifies its position.

AQA pseudocode uses 1-based indexing by convention (first element is at index 1). Check whether your language uses 0-based (Python, Java, C++) or 1-based indexing.

1D array declaration and access:

DECLARE scores[5] : INTEGER      // Array of 5 integers

scores[1] ← 85
scores[2] ← 72
scores[3] ← 91
scores[4] ← 67
scores[5] ← 88

OUTPUT scores[3]    // 91

Array traversal — process every element using a loop:

total ← 0
FOR i ← 1 TO 5
    total ← total + scores[i]
NEXT i
average ← total / 5

A 2D array stores data in rows and columns — like a table or grid. It is accessed with two indices: array[row][column].

DECLARE grid[3][3] : INTEGER    // 3×3 grid

// Populate with zeroes
FOR r ← 1 TO 3
    FOR c ← 1 TO 3
        grid[r][c] ← 0
    NEXT c
NEXT r

grid[2][3] ← 7    // Row 2, column 3 = 7
OUTPUT grid[2][3] // 7

Example use: a chessboard is an 8×8 2D array; a multiplication table is a 12×12 2D array; an image is a 2D array of pixel values.

Multi-dimensional arrays extend to 3 or more dimensions — for example, a 3D array could represent a data cube (rows × columns × depth).

Programs often need to persist data beyond a single run by reading from and writing to files. AQA requires knowledge of:

Operation	AQA pseudocode	Effect
Open for reading	OPENFILE "data.txt" FOR READ	Opens file; positions at start
Open for writing	OPENFILE "data.txt" FOR WRITE	Opens file; overwrites content
Open for appending	OPENFILE "data.txt" FOR APPEND	Opens file; positions at end
Read one line	READFILE "data.txt", line	Reads next line into line
Write one line	WRITEFILE "data.txt", value	Writes value then newline
Check end of file	EOF("data.txt")	Returns True if at end
Close	CLOSEFILE "data.txt"	Closes file; writes buffered data

Worked example — read all lines from a file and output each:

OPENFILE "students.txt" FOR READ
WHILE NOT EOF("students.txt") DO
    READFILE "students.txt", name
    OUTPUT name
ENDWHILE
CLOSEFILE "students.txt"

Files must be closed after use. Unclosed files can cause data loss (unflushed buffer) or prevent other programs from accessing the file.

Sequential access — data must be read from the beginning in order. Reading record 50 requires reading records 1 through 49 first. Used for log files, streaming data.

Random access — any record can be accessed directly by its position (address). Used for databases and binary files where records have a fixed size.

For the same file of fixed-size records [Rec1][Rec2][Rec3]...[Rec50], sequential access must read records 1 to 49 before reaching record 50, whereas random access computes the address of any record directly:

$\text{address}=\text{start}+(N-1)\times \text{record size}$

Magnetic tape only supports sequential access. Hard disks and SSDs support random access.

An abstract data type (ADT) defines a data structure in terms of its behaviour — the operations it supports — without specifying how it is implemented internally.

This separation is important:

• Code that uses an ADT depends only on its defined interface
• The implementation can change (e.g. from array-based to linked-list-based) without affecting any calling code
• Different implementations can be substituted without rewriting user code

ADT	Core operations	Defining property
Stack	push, pop, peek, isEmpty	LIFO
Queue	enqueue, dequeue, isEmpty	FIFO
List	append, insert, delete, search, get	Ordered, indexed
Dictionary	set, get, delete, contains	Key-value lookup
Graph	addVertex, addEdge, getNeighbours	Vertex-edge structure

Interface vs implementation:

Interface (what):       Stack.push(item), Stack.pop(), Stack.isEmpty()
Implementation (how):   Could use an array with a top pointer,
                        or a linked list with a head pointer —
                        the calling code cannot tell the difference.

1. Using the wrong index base

AQA pseudocode is 1-indexed; Python is 0-indexed. Accessing scores[0] in AQA pseudocode is typically out of bounds. Be explicit about which convention you are using in exam answers.

2. Declaring an array too small by one

If you need to store 10 items, declare DECLARE arr[10] — not DECLARE arr[9]. Off-by-one errors here produce index-out-of-bounds errors at runtime.

3. Not closing files after use

Forgetting CLOSEFILE may leave data unwritten (buffered but not flushed to disk) or prevent other processes from accessing the file.

4. Conflating an ADT with its implementation

A stack is an ADT — it could be implemented using an array or a linked list. Describing a stack as "an array" in an exam answer conflates the abstraction with one particular implementation.