Arrays in IGCSE AQA Computer Science | IGCSE AQA 计算机：数组考点精讲

📚 Arrays in IGCSE AQA Computer Science | IGCSE AQA 计算机：数组考点精讲

Arrays are one of the most fundamental data structures in computer science, and they form a key part of the IGCSE AQA syllabus. An array stores a fixed number of values of the same data type under a single variable name, allowing efficient access and manipulation. This article breaks down every essential array concept you need, from declaration to 2D arrays, with clear explanations, practical examples, and common exam pitfalls.

数组是计算机科学中最基本的数据结构之一，也是 IGCSE AQA 考纲的重要组成部分。数组能够在单个变量名下存储固定数量的同类型数据，实现高效的访问与操作。本文将逐一解析你所需掌握的每一个核心数组概念，涵盖声明、二维数组等，并配有清晰的解释、实用示例和常见考试失分点。

1. What is an Array? | 什么是数组？

An array is a data structure that can hold multiple items, all of the same data type, in contiguous memory locations. Each item is stored in an element, and every element is accessed using an integer position called an index. The main advantage is that the whole collection can be referred to by one identifier, and any value can be retrieved instantly if you know its index.

数组是一种可以在连续内存空间中存储多个同类型数据项的数据结构。每个数据项存储在一个元素中，每个元素通过一个称为索引的整数位置来访问。主要优势在于整个集合可以用一个标识符指代，并且只要知道索引就能立即获取任何值。

In pseudocode used by AQA, an array is often written with square brackets and indices, such as examMarks[0] ← 75. A typical array declaration would look like DECLARE examMarks : ARRAY[0:29] OF INTEGER. This creates 30 slots indexed from 0 to 29, all capable of storing integers. The size is fixed after creation, meaning you cannot dynamically expand it during runtime.

在 AQA 所用的伪代码中，数组通常使用方括号和索引表示，例如 examMarks[0] ← 75。典型的数组声明格式为 DECLARE examMarks : ARRAY[0:29] OF INTEGER。这将创建 30 个从 0 到 29 编号的存储槽，全部可存储整数。数组创建后大小固定，意味着运行时不能动态扩展。

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

Declaration tells the program the identifier, size, and data type of the array. In AQA pseudocode you specify the lower and upper index bounds, e.g., ARRAY[1:10] OF STRING or ARRAY[0:4] OF REAL. It is vital to include the data type, as an array can only hold one type. Some languages allow implicit declaration, but AQA requires explicit declaration for clarity and marks.

声明会告知程序数组的标识符、大小和数据类型。在 AQA 伪代码中你需要指定索引下界和上界，例如 ARRAY[1:10] OF STRING 或 ARRAY[0:4] OF REAL。包含数据类型至关重要，因为数组只能存储一种类型。有些语言允许隐式声明，但 AQA 要求明确声明，以保证清晰并拿到分数。

Initialisation means assigning values to the array elements at the time of creation. You can initialise an array element by element, like names[0] ← ‘Alice’, or use a loop to fill it with default values or user input. AQA questions may also present a pre-filled array using a table or list of values. Understanding how to write efficient initialisation code is essential for practical tasks and trace-table exercises.

初始化是指在创建时为数组元素赋值。你可以逐元素初始化，如 names[0] ← ‘Alice’，或使用循环填入默认值或用户输入。AQA 考题也可能以表格或数值列表的形式给出预先填充好的数组。掌握如何编写高效的初始化代码对实践任务和跟踪表练习至关重要。

3. Accessing Array Elements | 访问数组元素

Each element is accessed by writing the array name followed by the index in square brackets. For example, temperature[5] refers to the sixth element when indices start at 0. Reading a value from an array simply uses the expression in an output or assignment statement; modifying a value requires placing the array reference on the left side of an assignment.

每个元素通过数组名后跟方括号中的索引来访问。例如，当索引从 0 开始时，temperature[5] 指第六个元素。读取数组值只需在输出或赋值语句中使用该表达式；修改值则需要将数组引用放在赋值语句的左侧。

A common mistake is confusing the element position with the index value. If an array has 10 elements and is indexed from 0, the last element is data[9], not data[10]. Another pitfall is using a variable as the index without checking its range; this can lead to ‘index out of bounds’ errors. In pseudocode you can use expressions like scores[i+1] as long as the computed index falls within the declared range.

一个常见错误是混淆元素位置和索引值。如果数组有 10 个元素且索引从 0 开始，最后一个元素是 data[9]，而非 data[10]。另一个误区是用变量作索引但不检查其范围，这会导致“索引越界”错误。在伪代码中，只要计算出的索引值在声明范围内，就可以使用如 scores[i+1] 这样的表达式。

4. Index Values and Zero-Based Indexing | 索引值与零基索引

Most programming languages use zero-based indexing, where the first element is at index 0. AQA pseudocode allows the boundaries to be explicitly declared, so you might see ARRAY[0:9] for 10 elements or ARRAY[1:10] for the same count. In zero-based indexing, the highest index is length – 1. This mapping is essential for loop conditions: a FOR i ← 0 TO 9 loop perfectly iterates over a 10‑element zero‑based array.

大多数编程语言采用零基索引，首个元素的索引为 0。AQA 伪代码允许显式声明边界，因此对于 10 个元素，你可能会看到 ARRAY[0:9] 或 ARRAY[1:10]。在零基索引中，最高索引为 长度 – 1。这种映射对循环条件至关重要：FOR i ← 0 TO 9 循环将完美遍历一个 10 个元素的零基数组。

If an array is declared with bounds [1:10], the first element is at index 1 and the last at index 10. Some algorithms (such as linear search) are easier to reason about when indices match element numbers, but modern programming practice strongly favours zero-based indexing. In the exam, always respect the bounds given in the question; do not assume one style unless stated.

如果数组声明为 [1:10]，则第一个元素索引为 1，最后一个为 10。某些算法（如线性搜索）在索引与元素序号匹配时更易于推理，但现代编程实践强烈倾向于零基索引。考试中务必遵守题目给出的边界；除非明确说明，否则不要假定任何一种风格。

5. Traversing an Array with Loops | 使用循环遍历数组

Traversal means visiting each element of the array exactly once, usually to read, display, or process the data. A FOR loop is the most common way: the loop counter acts as the index, starting at the lower bound and finishing at the upper bound. For a zero‑based array of size n, the loop header is FOR i ← 0 TO n-1.

遍历意味着恰好访问数组的每个元素一次，通常是为了读取、显示或处理数据。FOR 循环是最常见的方式：循环计数器充当索引，从下界开始到上界结束。对于大小为 n 的零基数组，循环头为 FOR i ← 0 TO n-1。

While loops are used when the number of iterations depends on a condition, for example searching for a target value until found or reaching the end. A WHILE loop must contain a statement to increment the index and a guard against going beyond the array bounds. Always initialise the index variable before the loop and update it inside the loop body to avoid infinite repetition.

当迭代次数取决于某个条件时，使用 while 循环，例如搜索目标值直至找到或到达末尾。WHILE 循环必须包含递增索引的语句以及防止越界的检查。务必在循环前初始化索引变量，并在循环体内更新它，以避免无限重复。

6. Common Array Operations and Algorithms | 常见数组操作与算法

Several classic algorithms are explicitly examined. Linear search involves iterating through the array and comparing each element with the search key; it has O(n) time complexity. Finding the maximum or minimum requires storing the first element as the current best and updating it whenever a more extreme value is encountered. Summing and averaging are straightforward: accumulate the total in a variable and divide by the count for the average.

有几个经典算法是明确的考点。线性搜索涉及遍历数组并将每个元素与搜索键比较；其时间复杂度为 O(n)。寻找最大值或最小值需要将第一个元素存储为当前最佳值，并在遇到更极端的值时更新。求和与求平均值则直接：在一个变量中累加总和，再除以元素个数得到平均值。

Counting occurrences of a condition (e.g., how many marks above 50) is done by setting a counter to zero and incrementing it inside an IF statement. Bubble sort is sometimes used to illustrate array manipulation; it repeatedly swaps adjacent elements if they are in the wrong order. Bubble sort has O(n²) time complexity and helps reinforce nested loops and swapping logic.

统计满足条件的次数（例如有多少分数高于 50）通过将计数器设为零，并在 IF 语句中递增来完成。冒泡排序有时用于说明数组操作；它会在相邻元素顺序错误时反复交换它们。冒泡排序的时间复杂度为 O(n²)，有助于巩固嵌套循环和交换逻辑。

7. Two-Dimensional Arrays | 二维数组

A two‑dimensional (2D) array can be visualised as a table with rows and columns. In AQA pseudocode you declare a 2D array with two index ranges, for example DECLARE grid : ARRAY[1:3, 1:4] OF INTEGER. This creates 3 rows and 4 columns, giving 12 cells. To access an element, you provide both indices: grid[2,1] ← 15.

二维数组可以想象成有行和列的表格。在 AQA 伪代码中，声明二维数组时需要两个索引范围，例如 DECLARE grid : ARRAY[1:3, 1:4] OF INTEGER。这将创建 3 行 4 列，共 12 个单元格。访问元素需提供两个索引：grid[2,1] ← 15。

Traversal of a 2D array usually requires nested loops: an outer loop for rows and an inner loop for columns. This structure is vital for processing totals, searching for a value, or displaying the contents in a tabular format. You must be comfortable writing pseudocode that reads from or writes to a 2D array, and you should understand how the order of loops changes the access pattern (row‑major vs column‑major).

二维数组的遍历通常需要嵌套循环：外层循环处理行，内层循环处理列。这种结构对于处理总计、搜索值或以表格格式显示内容至关重要。你必须能够熟练编写读写二维数组的伪代码，并理解循环顺序如何改变访问模式（行优先与列优先）。

8. Arrays vs Lists | 数组与列表的区别

In IGCSE AQA, arrays have a fixed size, while lists are data structures that can grow and shrink dynamically. In pseudocode, lists are often written with curly braces or specific list commands, but the distinction is mainly conceptual: an array’s length is immutable once declared, whereas a list’s length can change by appending or removing items.

在 IGCSE AQA 中，数组具有固定大小，而列表是可以动态增长和收缩的数据结构。伪代码中列表通常用花括号或特定的列表命令表示，但区别主要是概念性的：数组的长度一旦声明就不可改变，而列表的长度可以通过追加或移除项目来改变。

Another practical difference is that pre‑defined array‑like structures in many languages (e.g., Python’s list) are actually dynamic lists, not static arrays. AQA might ask you to recognise the properties of an array: direct access by index, homogeneous data type, and fixed length. Understanding this contrast helps in choosing the right structure for a given scenario, such as using an array for known student counts vs a list when enrolment may change.

另一个实际区别在于，许多语言中预定义的类数组结构（如 Python 的 list）实际上是动态列表，而非静态数组。AQA 可能要求你识别数组的性质：通过索引直接访问、同质数据类型和固定长度。理解这一对比有助于为给定场景选择正确结构，例如已知学生人数时使用数组，而注册人数可能变化时使用列表。

9. Handling Array Boundaries and Errors | 处理数组边界与错误

One of the most common runtime errors is ‘index out of bounds’, which occurs when trying to access an index that is less than the lower bound or greater than the upper bound. In pseudocode this leads to program termination if not handled. Defensive programming techniques such as validating the index before use, using LEN() or a known constant for bounds, and writing careful loop conditions help prevent such errors.

最常见的运行时错误之一是“索引越界”，即尝试访问小于下界或大于上界的索引。在伪代码中，若不处理将导致程序终止。防御式编程技巧，如在使用前验证索引、通过 LEN() 或已知常量处理边界、编写谨慎的循环条件，有助于防止此类错误。

When writing algorithms that rely on index arithmetic, always check that i+1 or i-1 stays within the declared range. In bubble sort, for example, the inner loop must stop one element before the end to compare i with i+1. AQA examiners look for these boundary details; forgetting them can cost marks even if the algorithm logic is otherwise correct.

编写依赖索引运算的算法时，务必检查 i+1 或 i-1 是否保持在声明范围内。例如在冒泡排序中，内循环必须在末尾前一个元素停止，以便比较 i 与 i+1。AQA 考官会关注这些边界细节；忽略它们即使算法逻辑正确也可能失分。

10. Exam Tips and Common Pitfalls | 考试技巧与常见误区

First, always declare the array with explicit bounds and a data type, matching the question’s specification. In trace-table questions, track the index variable and the element it points to separately. A frequent error is incrementing the index but forgetting to update the array element, or vice versa. Practice converting a written description into a working pseudocode loop, especially for 2D arrays.

首先，务必按照题目要求为数组声明明确的边界和数据类型。在跟踪表题目中，要分别跟踪索引变量及其指向的元素。一个常见错误是递增了索引却忘记更新数组元素，反之亦然。练习将文字描述转换为可运行的伪代码循环，尤其对于二维数组。

Second, watch for off-by-one mistakes. If a question says ‘the first value is in position 1’, you may prefer lower‑bound 1; otherwise, default to 0. When calculating averages, ensure you divide by the actual number of elements, not the array size, if some slots are unfilled. Finally, use meaningful variable names like totalRainfall or maxMark rather than single letters—this improves readability.

其次，注意差一错误。如果题目说“第一个值在位置 1”，你可能更倾向于下界为 1；否则默认使用 0。计算平均值时，如果有槽位未填充，确保除以实际元素个数而非数组大小。最后，使用有意义的变量名如 totalRainfall 或 maxMark，而不是单个字母——这会提高可读性。

11. Summary | 总结

Arrays allow you to store and manipulate collections of homogeneous data efficiently. Key skills for the IGCSE AQA examination include declaring arrays with correct bounds, accessing elements using zero‑based or custom indices, traversing with FOR loops, implementing linear search and find‑max/min algorithms, handling 2D arrays with nested loops, and recognising the difference between fixed‑size arrays and dynamic lists. Always validate array bounds and check loop termination conditions to avoid off‑by‑one errors.

数组使你能高效地存储和操作同质数据集合。IGCSE AQA 考试的关键技能包括：用正确的边界声明数组、使用零基索引或自定义索引访问元素、用 FOR 循环遍历、实现线性搜索和查找最大/最小值算法、用嵌套循环处理二维数组，以及识别固定大小数组与动态列表的区别。始终验证数组边界并检查循环终止条件，避免差一错误。

By mastering these concepts and practicing pseudocode writing, you will build a solid foundation for all data structure questions on the paper and be well prepared for the programming tasks that require array manipulation.

通过掌握这些概念并练习伪代码写作，你将为试卷中所有数据结构题目打下坚实基础，并充分准备好应对需要数组操作的编程任务。

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

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

Arrays in IGCSE AQA Computer Science | IGCSE AQA 计算机：数组 考点精讲