Arrays Exam Focus for A-Level CCEA Computer Science | A-Level CCEA 计算机：数组考点精讲

📚 Arrays Exam Focus for A-Level CCEA Computer Science | A-Level CCEA 计算机：数组考点精讲

Arrays are one of the foundational data structures in computer science. In the CCEA A-Level specification, understanding how to declare, manipulate, and apply arrays in algorithms is essential for both programming tasks and theoretical exam questions. This revision guide breaks down every key concept you need to master.

数组是计算机科学中最基础的数据结构之一。在 CCEA A-Level 考试大纲中，掌握数组的声明、操作以及在算法中的应用，对编程任务和理论考题都至关重要。这份精讲将为你拆解每个必须掌握的核心概念。

1. Definition and Core Concepts | 定义与核心概念

An array is a collection of elements, all of the same data type, stored in contiguous memory locations. Each element can be accessed directly using an index, which usually starts at 0 or 1 depending on the language or pseudocode convention.

数组是一组相同数据类型的元素，存储在连续的内存位置上。每个元素可以通过索引直接访问，索引通常从 0 或 1 开始，具体取决于语言或伪代码约定。

Arrays are static in many A-Level contexts, meaning their size is fixed at the time of declaration. However, some questions may refer to dynamic arrays that can be resized during runtime.

在 A-Level 的许多场景中，数组是静态的，即其大小在声明时就已固定。但有些题目可能会提到可在运行时调整大小的动态数组。

Key properties:

Homogeneous – all elements share the same type.
Random access – any element can be accessed in O(1) time using its index.
Fixed size – once created, the number of elements cannot change (for static arrays).

关键属性：

同质性——所有元素类型相同。
随机访问——任何元素都可以通过索引在 O(1) 时间内访问。
固定大小——一旦创建，元素个数不可更改（静态数组）。

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

In pseudocode and high-level languages, arrays must be declared with a name, size, and data type. CCEA often uses a syntax similar to VB.NET or generic pseudocode.

在伪代码和高级语言中，数组必须声明名称、大小和数据类型。CCEA 通常使用类似 VB.NET 或通用伪代码的语法。

Example declaration of an integer array with 5 elements, index starting at 0:

声明一个有 5 个元素的整数数组，索引从 0 开始的示例：

DECLARE numbers[0:4] OF INTEGER

Initialisation can happen at declaration or later using assignment statements:

初始化可以在声明时进行，也可以随后通过赋值语句完成：

numbers ← [4, 7, 2, 9, 1]

Table summarising declaration styles across languages:

Language	Declaration
VB.NET	Dim arr(4) As Integer
Python (list-based)	arr = [0] * 5
CCEA Pseudocode	DECLARE arr[0:4] OF INTEGER

下表总结了不同语言的声明风格：

语言	声明
VB.NET	Dim arr(4) As Integer
Python（基于列表）	arr = [0] * 5
CCEA 伪代码	DECLARE arr[0:4] OF INTEGER

3. Indexing and Element Access | 索引与元素访问

Indexing is the mechanism used to retrieve or modify an element. The index is placed in square brackets after the array name. Most CCEA pseudocode examples use zero-based indexing, but always read the question carefully.

索引是用于检索或修改元素的机制。索引放在数组名后的方括号内。大多数 CCEA 伪代码示例使用从 0 开始的索引，但务必仔细阅读题目。

Accessing the first element:

访问第一个元素：

value ← numbers[0]

Updating the third element to 15:

将第三个元素更新为 15：

numbers[2] ← 15

Incorrect indexing, such as reading or writing outside the declared bounds, causes an ‘index out of bounds’ error. CCEA exam questions frequently test your ability to identify such runtime errors.

错误的索引（如读取或写入超出声明范围的位置）会导致“索引越界”错误。CCEA 考试题常考查你是否能识别这类运行时错误。

4. Traversing Arrays | 遍历数组

Traversal means visiting each element of the array, usually using a loop. The most common approach is a FOR loop that increments an index from the lower bound to the upper bound.

遍历指访问数组的每一个元素，通常使用循环。最常见的方法是使用 FOR 循环，让索引从下限递增到上限。

Example pseudocode to print all elements:

打印所有元素的伪代码示例：

FOR i ← 0 TO 4
OUTPUT numbers[i]
ENDFOR

Alternatively, a WHILE loop can be used, especially when the stopping condition depends on a specific value (e.g., a sentinel).

也可以使用 WHILE 循环，特别是当结束条件依赖于特定值（如哨兵值）时。

For two-dimensional arrays, nested loops are required. The outer loop iterates over rows, the inner loop over columns.

对于二维数组，需要使用嵌套循环。外层循环遍历行，内层循环遍历列。

FOR row ← 0 TO 2
  FOR col ← 0 TO 3
    OUTPUT grid[row][col]
  ENDFOR
ENDFOR

5. One-Dimensional and Two-Dimensional Arrays | 一维数组与二维数组

A one-dimensional (1D) array is a simple list of elements. It can be visualised as a row of values. A two-dimensional (2D) array can be thought of as a table with rows and columns, often used to represent grids, matrices, or game boards.

一维（1D）数组是一个简单的元素列表，可视作一行值。二维（2D）数组则可视为包含行和列的表格，常用于表示网格、矩阵或棋盘。

Declaration of a 2D array with 3 rows and 4 columns:

声明一个具有 3 行 4 列的二维数组：

DECLARE grid[0:2, 0:3] OF STRING

Accessing an element at row 1, column 2:

访问第 1 行第 2 列的元素：

item ← grid[1][2]

CCEA questions may ask you to write algorithms that perform row-wise or column-wise sums, find a specific pattern, or transpose a matrix.

CCEA 考题可能要求你编写按行或按列求和、查找特定模式或转置矩阵的算法。

6. Array Operations: Insertion, Deletion, and Updating | 数组操作：插入、删除与更新

In static arrays, insertion and deletion are not trivial because the size cannot change. To insert a new element, all subsequent elements must be shifted to the right, provided there is space. Similarly, deletion requires shifting elements to the left and leaving a placeholder (like 0 or an empty string) at the end.

在静态数组中，插入和删除并不简单，因为大小不可改变。要插入新元素，必须将所有后续元素向右移动（前提是有空间）。类似地，删除需要将元素向左移动，并在末尾留下占位符（如 0 或空字符串）。

Algorithm for inserting value x at position p in an array of size n (when there is at least one free slot):

在大小为 n 的数组中位置 p 插入值 x 的算法（假设至少有一个空闲槽位）：

FOR i ← n-1 DOWNTO p
arr[i+1] ← arr[i]
ENDFOR
arr[p] ← x

Updating an element is much simpler: just overwrite the value at a given index. This is an O(1) operation.

更新元素简单得多：只需要覆盖给定索引处的值。这是一个 O(1) 操作。

Be aware of the difference between logical size (number of meaningful elements) and physical size (capacity). Many CCEA questions use a separate counter variable to track the logical size.

请注意逻辑大小（有意义的元素个数）和物理大小（容量）之间的区别。许多 CCEA 考题会用一个单独的计数器变量来跟踪逻辑大小。

7. Searching Algorithms on Arrays | 数组上的搜索算法

Two fundamental searching algorithms are examined: linear search and binary search. You must know how they work, their pseudocode, and their efficiency.

考试涉及两种基本的搜索算法：线性搜索和二分搜索。你必须了解它们的工作原理、伪代码及效率。

Linear Search

Linear search checks each element in sequence until the target is found or the end is reached. It works on both unsorted and sorted arrays. Worst-case time complexity is O(n).

线性搜索

线性搜索按顺序检查每个元素，直到找到目标或到达末尾。它适用于未排序和已排序的数组。最坏情况时间复杂度为 O(n)。

found ← FALSE
FOR i ← 0 TO n-1
  IF arr[i] = target THEN
    OUTPUT i
    found ← TRUE
  ENDIF
ENDFOR

Binary Search

Binary search repeatedly divides a sorted array in half. It compares the middle element with the target, discarding the half that cannot contain the target. Time complexity is O(log n).

二分搜索

二分搜索反复将已排序数组分成两半。它将中间元素与目标值比较，舍弃不可能包含目标的那一半。时间复杂度为 O(log n)。

low ← 0
high ← n-1
found ← FALSE
WHILE low <= high AND NOT found
  mid ← (low + high)/2
  IF arr[mid] = target THEN
    found ← TRUE
  ELSE IF arr[mid] < target THEN
    low ← mid + 1
  ELSE
    high ← mid – 1
  ENDIF
ENDWHILE

The exam often asks you to trace binary search step by step or compare the efficiency of the two methods.

考试经常要求你逐步跟踪二分搜索的过程，或比较这两种方法的效率。

8. Sorting Arrays | 数组排序

CCEA A-Level requires understanding of at least two sorting algorithms: bubble sort and insertion sort. Both can be implemented on a 1D array.

CCEA A-Level 要求理解至少两种排序算法：冒泡排序和插入排序。两者均可在一维数组上实现。

Bubble Sort

Bubble sort repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The largest element ‘bubbles’ to the end in each pass. Optimised versions stop if no swaps occur.

冒泡排序

冒泡排序反复遍历列表，比较相邻元素，如果顺序错误则交换。每一轮结束后，最大的元素会“冒泡”到末尾。如果某一轮没有发生交换，优化版本会提前停止。

FOR i ← 0 TO n-2
  swapped ← FALSE
  FOR j ← 0 TO n-2-i
    IF arr[j] > arr[j+1] THEN
      SWAP arr[j], arr[j+1]
      swapped ← TRUE
    ENDIF
  ENDFOR
  IF NOT swapped THEN EXIT FOR
ENDFOR

Insertion Sort

Insertion sort builds the final sorted array one element at a time. It takes an element from the unsorted part and inserts it into its correct position in the sorted part.

插入排序

插入排序一次构建一个元素的最终已排序数组。它从未排序部分取出一个元素，并将其插入到已排序部分的正确位置。

FOR i ← 1 TO n-1
  key ← arr[i]
  j ← i – 1
  WHILE j >= 0 AND arr[j] > key
    arr[j+1] ← arr[j]
    j ← j – 1
  ENDWHILE
  arr[j+1] ← key
ENDFOR

Exam questions may require you to compare their efficiency (both average O(n²)), describe the state of the array after each pass, or suggest which algorithm performs better on nearly sorted data (insertion sort).

考题可能要求你比较它们的效率（平均都是 O(n²)），描述每一轮过后数组的状态，或建议哪种算法在接近有序的数据上表现更好（插入排序）。

9. Common Errors and Boundaries | 常见错误与边界问题

Array questions often test your ability to avoid off-by-one errors. Forgetting that an array of size 5 declared as arr[0:4] has valid indices 0,1,2,3,4 is a classic mistake. Accessing arr[5] will cause a bounds error.

数组题目经常测试你避免“差一错误”（off-by-one）的能力。如果忘记大小为 5 的数组 arr[0:4] 的有效索引是 0,1,2,3,4，就是经典错误。访问 arr[5] 将导致越界错误。

Another typical error is confusing the physical size with the number of currently stored elements. When a partially filled array is used, the logical size must be maintained separately.

另一个典型错误是混淆物理大小和当前存储的元素个数。当使用部分填充的数组时，必须单独维护逻辑大小。

In 2D arrays, always remember that the first index is the row and the second is the column. Swapping them can lead to incorrect data access or out-of-bounds errors.

在二维数组中，永远记住第一个索引是行，第二个是列。交换它们会导致错误的数据访问或越界。

10. Arrays in Pseudocode and Programming Practice | 伪代码与编程实践中的数组

CCEA exams often ask you to write pseudocode that manipulates arrays. Follow the standard conventions: use DECLARE, OUTPUT, INPUT, FOR…ENDFOR, IF…ENDIF. Arrow ← for assignment.

CCEA 考试经常要求编写操作数组的伪代码。遵循标准约定：使用 DECLARE、OUTPUT、INPUT、FOR…ENDFOR、IF…ENDIF。赋值使用箭头 ←。

When implementing arrays in a programming language like Python or VB.NET for coursework, be aware that Python’s lists are dynamic and have built-in methods (append, insert, pop) that simplify insertion and deletion. You must still be able to write low-level algorithms that shift elements manually for the exam.

在课程作业中使用 Python 或 VB.NET 等编程语言实现数组时，请注意 Python 列表是动态的，并内置了简化插入和删除的方法（append、insert、pop）。但考试中你仍需能够手写底层算法来手动移动元素。

Practice tracing given pseudocode. Many exam marks come from showing the contents of an array after a series of operations. Draw a table with index and value to avoid confusion.

练习跟踪给定的伪代码。许多考试分数来自展示一系列操作后数组的内容。画一个包含索引和值的表格以避免混淆。

11. Application in Algorithms and Data Handling | 数组在算法与数据处理中的应用

Arrays are used extensively in solving real A-Level problems: storing student marks, implementing a queue or stack (with an array and pointers), representing a tic-tac-toe board, or processing sensor data.

数组广泛应用于解决 A-Level 的实际问题：存储学生成绩、实现队列或栈（通过数组和指针）、表示井字棋棋盘，或处理传感器数据。

For example, finding the maximum value in an array:

例如，查找数组中的最大值：

max ← arr[0]
FOR i ← 1 TO n-1
  IF arr[i] > max THEN
    max ← arr[i]
  ENDIF
ENDFOR

Counting occurrences of a specific value:

计算特定值的出现次数：

count ← 0
FOR i ← 0 TO n-1
IF arr[i] = target THEN count ← count + 1
ENDFOR

Understanding these patterns helps you tackle unseen problems in the exam.

理解这些模式有助于你在考试中解决从未见过的问题。

12. Exam Tips and Summary | 考试技巧与总结

To excel in array-based questions on the CCEA paper:

Always initialise counters and flags.
Double-check loop boundaries and index ranges.
Be able to convert between pseudocode and a trace table.
Learn the standard algorithms for searching and sorting by heart.
Manage partially filled arrays with a logical size variable.
Clearly state assumptions about index origin if not given.

要在 CCEA 试卷的数组题目中取得高分：

始终初始化计数器和标志。
仔细检查循环边界和索引范围。
能够在伪代码和跟踪表之间转换。
牢记搜索和排序的标准算法。
使用逻辑大小变量管理部分填充的数组。
如未给出，请明确说明索引起点的假设。

Arrays underpin many abstract data structures and algorithms. Mastering them now will build confidence for topics such as queues, stacks, and dynamic data structures in the A-Level course.

数组是许多抽象数据结构和算法的基础。现在掌握它们将为 A-Level 课程中的队列、栈和动态数据结构等主题树立信心。

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

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

Arrays Exam Focus for A-Level CCEA Computer Science | A-Level CCEA 计算机：数组 考点精讲