Array Essentials for CIE A-Level Computer Science | CIE A-Level 计算机科学：数组核心考点精讲

📚 Array Essentials for CIE A-Level Computer Science | CIE A-Level 计算机科学：数组核心考点精讲

Arrays are a fundamental data structure in CIE A-Level Computer Science. They provide a way to store multiple items of the same data type in a single variable using contiguous memory locations. Mastery of array manipulation, searching, and sorting is essential for success in both the pseudocode and programming questions on the exam.

数组是 CIE A-Level 计算机科学中的基础数据结构。它允许将多个相同数据类型的元素存储在连续的内存单元中，并通过单个变量名访问。彻底掌握数组的操作、搜索和排序是攻克考试中伪代码及编程题的关键。

1. Definition and Core Properties | 定义与核心属性

An array is a static, homogeneous collection of elements, each identified by an index. All elements share the same data type, and the size of the array is fixed at declaration in most exam contexts. In memory, array elements occupy consecutive addresses, which enables efficient indexed access.

数组是一种静态的、同质的数据集合，其中每个元素通过索引标识。所有元素具有相同的数据类型，且在大多数考试情境下数组的大小在声明时就固定下来。在内存中，数组元素占用连续的地址，这使得基于索引的访问非常高效。

You should be able to distinguish between the logical size (how many elements are actually used) and the physical capacity (the maximum size declared).

你需要能够区分逻辑大小（实际使用的元素个数）和物理容量（声明时的最大尺寸）。

In CIE pseudocode, the array index base is 1 by default, unlike Python where indexing starts at 0. Always check the question or specification to avoid off-by-one errors.

在 CIE 伪代码中，数组索引默认从 1 开始，而 Python 中索引从 0 开始。务必检查题目说明或规范，以避免“差一”错误。

2. Declaring and Initialising Arrays | 数组的声明与初始化

In CIE pseudocode, a one-dimensional array is declared with a name, index range, and data type:

在 CIE 伪代码中，一维数组的声明需要给出数组名、索引范围以及数据类型：

DECLARE studentMarks : ARRAY[1:30] OF INTEGER

Elements can then be assigned individually:

随后可以逐个为元素赋值：

studentMarks[1] ← 85
studentMarks[2] ← 92

In Python, an equivalent creation would be:

在 Python 中，等价的创建方式可以是：

studentMarks = [0] * 30  # fixed length with default values
studentMarks[0] = 85     # index 0 in Python

CIE exam questions may also ask you to interpret or write code that reads values into an array using a loop, a common pattern for initialisation.

CIE 考试题目也可能要求你解释或编写使用循环将数值读入数组的代码，这是一种常见的初始化模式。

3. Accessing and Modifying Elements | 访问与修改元素

Array elements are accessed via their index enclosed in square brackets. You can read the value or assign a new value to a specific position.

数组元素通过方括号中的索引来访问。你可以读取某个元素的值，也可以为特定位置赋予新值。

A key exam pitfall is attempting to access an index outside the declared bounds, e.g., `studentMarks[31]` when the upper bound is 30. This leads to an index out of range error. Pseudocode models often expect you to handle such validation explicitly.

一个重要的考试陷阱是试图访问声明范围之外的索引，例如当上界为30时使用了 `studentMarks[31]`。这会导致“索引越界”错误。伪代码模型通常要求你显式地处理这种验证。

You should also be able to read from and write to array elements inside iterative structures, which is the foundation of list processing.

你还应当能够在迭代结构中读取和写入数组元素，这是列表处理的基础。

4. Traversing a One-Dimensional Array | 一维数组的遍历

Traversal means visiting every element of an array, typically to perform an operation such as summing values, counting occurrences, or displaying data. A `FOR` loop is the standard method in both pseudocode and Python.

遍历意味着访问数组中的每一个元素，通常是为了执行诸如求和、统计出现次数或显示数据等操作。在伪代码和 Python 中，`FOR` 循环是标准的遍历方法。

Pseudocode for summing an array:

对数组求和的伪代码如下：

total ← 0
FOR i ← 1 TO LENGTH(arr)
    total ← total + arr[i]
NEXT i

In Python, using a 0‑based loop:

Python 中基于 0 的循环：

total = 0
for i in range(len(arr)):
    total += arr[i]

Many exam problems combine traversal with conditional checks inside the loop, for example identifying maximum or minimum values.

许多试题会将遍历与循环内部的条件判断结合起来，例如找出最大值或最小值。

5. Multi-Dimensional Arrays | 多维数组

Two-dimensional arrays (2D arrays) represent tables or grids. They are declared with two index ranges, typically [row, column] in CIE pseudocode.

二维数组（2D 数组）表示表格或网格。在 CIE 伪代码中，它们通过两个索引范围来声明，通常为 [行, 列]。

DECLARE board : ARRAY[1:8, 1:8] OF CHAR

Accessing a specific cell uses both coordinates: `board[3,2] ← ‘Q’`.

访问特定单元格时需要同时提供两个坐标：`board[3,2] ← ‘Q’`。

In Python, 2D arrays are implemented as lists of lists. Access is `board[2][1]` (row index 2, column index 1) because of 0‑based indexing.

在 Python 中，二维数组实现为列表的列表，由于 0 基索引，访问形式为 `board[2][1]`（行索引 2，列索引 1）。

Nested loops are required to traverse 2D arrays fully. Understanding row‑major and column‑major traversal helps in answering exam questions about matrix operations or image processing.

全面遍历二维数组需要嵌套循环。理解行优先遍历和列优先遍历有助于解答涉及矩阵运算或图像处理的考题。

6. Linear Search Algorithm | 线性搜索算法

Linear search is the simplest searching technique. It examines each element in sequence until the target is found or the end of the array is reached.

线性搜索是最简单的搜索技术。它依次检查每个元素，直到找到目标值或到达数组末尾。

Pseudocode for linear search on an array `arr` of size `n` looking for `searchValue`:

在大小为 `n` 的数组 `arr` 中搜索 `searchValue` 的线性搜索伪代码：

found ← FALSE
index ← 1
WHILE index ≤ n AND found = FALSE
    IF arr[index] = searchValue THEN
        found ← TRUE
    ELSE
        index ← index + 1
    ENDIF
ENDWHILE
IF found THEN
    OUTPUT index
ELSE
    OUTPUT "Value not found"
ENDIF

In the worst case, the algorithm must scan all `n` elements. Its time complexity is therefore O(n), making it inefficient for large datasets.

最坏情况下，该算法必须扫描全部 `n` 个元素，因此其时间复杂度为 O(n)，对于大数据集而言效率较低。

Linear search works on unsorted arrays and is suitable when the array size is small or the array is accessed infrequently.

线性搜索可以在无序数组上工作，当数组规模较小或访问不频繁时较为适宜。

7. Bubble Sort Algorithm | 冒泡排序算法

Bubble sort repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The pass is repeated until no swaps are needed.

冒泡排序反复遍历列表，比较相邻元素，若顺序错误则交换它们。重复执行遍历直到不需要任何交换为止。

A standard pseudocode for bubble sort:

冒泡排序的标准伪代码：

n ← LENGTH(arr)
FOR i ← 1 TO n-1
    FOR j ← 1 TO n-i
        IF arr[j] > arr[j+1] THEN
            temp ← arr[j]
            arr[j] ← arr[j+1]
            arr[j+1] ← temp
        ENDIF
    NEXT j
NEXT i

Bubble sort has a worst-case and average time complexity of O(n²). It is simple to implement but rarely used in practice for large data volumes. In exams, you may be asked to trace the algorithm or identify its inefficiency.

冒泡排序的最坏情况和平均时间复杂度均为 O(n²)。它实现简单，但在实际应用中很少用于大数据量。在考试中，你可能需要追踪算法步骤或指出其低效之处。

An optimized version can stop early if a full pass is made without any swaps, reducing best-case complexity to O(n).

优化版本可以在完整遍历中无交换时提前终止，将最好情况复杂度降至 O(n)。

8. Binary Search Algorithm | 二分搜索算法

Binary search is a highly efficient algorithm that works on sorted arrays. It repeatedly divides the search interval in half, comparing the middle element with the target value.

二分搜索是一种高效的算法，适用于有序数组。它反复将搜索区间对半分开，比较中间元素与目标值。

Iterative pseudocode for binary search:

二分搜索的迭代伪代码：

low ← 1
high ← n
found ← FALSE
WHILE low ≤ high AND found = FALSE
    mid ← (low + high) DIV 2
    IF arr[mid] = searchValue THEN
        found ← TRUE
    ELSE IF arr[mid] < searchValue THEN
        low ← mid + 1
    ELSE
        high ← mid - 1
    ENDIF
ENDWHILE
IF found THEN
    OUTPUT mid
ELSE
    OUTPUT "Not found"
ENDIF

The key advantage is the logarithmic time complexity: O(log n). This makes binary search ideal for large sorted datasets.

其主要优势在于对数时间复杂度：O(log n)。这使得二分搜索适用于大型有序数据集。

Always remember that binary search requires the array to be sorted beforehand; otherwise it will not work correctly.

一定要记住二分搜索要求数组预先排序，否则无法正确运行。

9. Implementing Stacks and Queues Using Arrays | 用数组实现栈和队列

Arrays serve as the underlying storage for abstract data types like stacks and queues, which are frequently tested in CIE papers.

数组可以作为栈和队列等抽象数据类型的底层存储，这些内容在 CIE 试卷中经常出现。

Stack (LIFO): You maintain a `top` pointer that indicates the index of the most recently added element. Push increments `top` and inserts the value; pop returns the value at `top` and decrements the pointer. Boundary checks prevent overflow and underflow.

栈 (LIFO)：维护一个 `top` 指针，指向最新添加的元素索引。Push 操作将 `top` 递增并插入新值；Pop 操作返回 `top` 处的值并将指针递减。边界检查可防止上溢和下溢。

Queue (FIFO): Using a linear array can lead to unused space after dequeues, so a circular queue is often employed. Two pointers, `front` and `rear`, track the head and tail. Wrapping around using modulo arithmetic makes efficient use of the array.

队列 (FIFO)：使用线性数组可能在出队后产生未用空间，因此常常采用循环队列。`front` 和 `rear` 两个指针分别跟踪队首和队尾。通过取模运算使指针回绕，以高效利用数组空间。

Exam questions may ask you to write pseudocode for `Enqueue`/`Dequeue` operations or to trace the state of a circular queue after a sequence of operations.

考题可能要求你编写 `Enqueue`/`Dequeue` 操作的伪代码，或者追踪一系列操作后循环队列的状态。

10. Advantages and Limitations of Arrays | 数组的优点与局限

Advantages \| 优点	Limitations \| 局限
Constant-time O(1) access to any element via its index. 通过索引实现常数时间 O(1) 的任意元素访问。 Simple and intuitive to use for storing sequential data. 存储顺序数据时简单直观。 Easy to implement algorithms such as linear search, bubble sort. 易于实现线性搜索、冒泡排序等算法。	Fixed size once declared; cannot grow or shrink dynamically. 一旦声明大小固定，无法动态增长或收缩。 Inserting or deleting an element (except at the end) is costly – O(n) – due to shifting. 插入或删除元素（末尾除外）因需要移动数据而代价较高，时间复杂度 O(n)。 Memory may be wasted if the array is declared much larger than needed. 若声明的数组远大于实际使用量则会浪费内存。

Advantages | 优点

Limitations | 局限

Constant-time O(1) access to any element via its index.
通过索引实现常数时间 O(1) 的任意元素访问。
Simple and intuitive to use for storing sequential data.
存储顺序数据时简单直观。
Easy to implement algorithms such as linear search, bubble sort.
易于实现线性搜索、冒泡排序等算法。

Fixed size once declared; cannot grow or shrink dynamically.
一旦声明大小固定，无法动态增长或收缩。
Inserting or deleting an element (except at the end) is costly – O(n) – due to shifting.
插入或删除元素（末尾除外）因需要移动数据而代价较高，时间复杂度 O(n)。
Memory may be wasted if the array is declared much larger than needed.
若声明的数组远大于实际使用量则会浪费内存。

These trade-offs explain why other data structures, like linked lists, are introduced later in the syllabus.

这些权衡解释了为什么教学大纲随后会引入链表等其他数据结构。

11. Common Exam Pitfalls and Tips | 常见考试陷阱与解题技巧

Many marks are lost because of small but critical mistakes. Keep these pointers in mind:

许多分数都因细小但关键的错误而丢失。请记住以下几点：

Index confusion: Always confirm whether the question uses 1‑based or 0‑based indexing. In CIE pseudocode, it is 1‑based unless stated otherwise.

索引混淆：务必确认题目使用的是 1 基索引还是 0 基索引。在 CIE 伪代码中，除非特别说明，均使用 1 基索引。
Missing loop counters: In a `FOR` loop, ensure you increment or update the counter correctly; many pre-release tasks involve array iterations.

遗漏循环计数器：在 `FOR` 循环中要确保正确递增或更新计数器；许多预发布任务涉及数组迭代。
Array size assumption: Do not hardcode magic numbers like 10 or 100. Use `LENGTH()` or `n` to make your solution general.

数组大小假设：不要硬编码如 10、100 之类的魔术数字，应使用 `LENGTH()` 或 `n` 使解答具有通用性。
Sorting stability: Know that bubble sort is stable (relative order of equal elements remains), but some other algorithms may not be.

排序稳定性：了解冒泡排序是稳定的（相等元素的相对顺序不变），而其他一些算法则可能不稳定。
Trace tables: When asked to complete a trace table for array operations, carefully update each cell and pointer after every statement.

追踪表：当要求为数组操作完成追踪表时，要在每一条语句后仔细更新每个单元格和指针。

12. Summary and Revision Checklist | 总结与复习清单

Arrays are ubiquitous in A-Level Computer Science. To be fully prepared:

数组在 A-Level 计算机科学中无处不在。为充分备考，你需要：

Understand declaration, initialisation, and the 1‑based vs 0‑based indexing rule for pseudocode.

理解数组的声明、初始化以及伪代码中 1 基索引与 0 基索引的规则。
Be able to write and trace standard algorithms: linear search, bubble sort, and binary search.

能够编写并追踪标准算法：线性搜索、冒泡排序及二分搜索。
Know how to implement stacks and queues using arrays, including circular queues.

掌握如何用数组实现栈和队列，包括循环队列。
Recognise the time complexities: O(1) for indexed access, O(n) for linear search, O(n²) for bubble sort, and O(log n) for binary search.

识记时间复杂度：索引访问为 O(1)，线性搜索为 O(n)，冒泡排序为 O(n²)，二分搜索为 O(log n)。
Practise past paper questions involving 1D and 2D arrays with trace tables.

练习历年真题中涉及一维和二维数组的追踪表题目。

Consistent practice with pseudocode and real code in Python will build the confidence needed for the exam.

坚持练习伪代码和真实的 Python 代码将为你建立考试所需的信心。

Published by TutorHao | Computer Science Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

Array Essentials for CIE A-Level Computer Science | CIE A-Level 计算机科学：数组核心考点精讲