Array Exam Essentials for A-Level OCR Computer Science | A-Level OCR 计算机：数组考点精讲

📚 Array Exam Essentials for A-Level OCR Computer Science | A-Level OCR 计算机：数组考点精讲

Arrays are one of the most fundamental data structures in the OCR A-Level Computer Science syllabus. Mastering their concepts, memory layout, operations, and algorithmic usage is essential for both theory papers and practical problem-solving. This article breaks down every key point you need to know, from one-dimensional and two-dimensional arrays to static versus dynamic implementations, traversal patterns, insertion and deletion mechanics, and how search algorithms like linear and binary search rely on array indexing. We also highlight common pitfalls and OCR-specific exam tips to help you score top marks.

数组是 OCR A-Level 计算机科学课程中最基础的数据结构之一。掌握数组的概念、内存布局、操作及算法应用，对理论试卷和实际解题都至关重要。本文逐一拆解所有关键知识点，涵盖一维数组与二维数组、静态与动态实现、遍历模式、插入与删除机制，以及线性搜索和二分搜索等算法如何依赖数组索引。文中还点明了常见误区及 OCR 专属考试技巧，助你拿下高分。

1. Introduction to Arrays in OCR A-Level | OCR A-Level 数组导论

An array is a collection of elements of the same data type, stored in contiguous memory locations. Each element can be accessed directly using an index. The OCR specification treats arrays as a core data structure for organising data, enabling efficient retrieval and manipulation. Arrays are typically zero-indexed in OCR pseudocode, meaning the first element is at index 0.

数组是同一数据类型元素构成的集合，元素存储在连续的内存位置中。每个元素可通过索引直接访问。OCR 考纲将数组视为组织数据的核心结构，支持高效检索与操作。在 OCR 伪代码中，数组通常采用零索引，即第一个元素的索引为 0。

When tackling OCR exam questions, you must be able to declare arrays, assign values, and write algorithms that traverse and modify them. Understanding that an array holds a fixed number of elements (in its static form) is crucial for analysing algorithm efficiency and memory usage.

解答 OCR 试题时，你必须能够声明数组、赋值，并编写遍历和修改数组的算法。理解数组（静态形式）具有固定元素个数，对分析算法效率和内存占用至关重要。

2. One-Dimensional Arrays | 一维数组

A one-dimensional array can be visualised as a single row of boxes. In OCR pseudocode, it is often declared with an index range. For example: DECLARE scores : ARRAY[0:4] OF INTEGER. This creates an array with indices 0, 1, 2, 3, 4, holding five integers.

一维数组可直观理解为一行格子。在 OCR 伪代码中，通常用索引范围声明。例如：DECLARE scores : ARRAY[0:4] OF INTEGER，该语句创建了一个索引为 0 到 4 的数组，可存放五个整数。

Accessing an element uses the syntax scores[2] to retrieve or assign the value at index 2. OCR assumes zero-based indexing unless stated otherwise. Pay attention to array bounds: referencing scores[5] in the above declaration would cause an out-of-bounds error, a common exam trap.

访问元素时使用 scores[2] 读取或赋予索引 2 处的值。OCR 默认采用零索引，除非另有说明。注意数组边界：在上述声明中引用 scores[5] 会导致越界错误，这是常见的考试陷阱。

One-dimensional arrays are frequently used to store lists of data such as student names, temperatures, or pixel values. You should be comfortable iterating over them with FOR loops, WHILE loops, or REPEAT…UNTIL structures depending on the exam question’s requirements.

一维数组常用于存储数据列表，如学生姓名、温度值或像素值。你应能根据题目要求，熟练使用 FOR 循环、WHILE 循环或 REPEAT…UNTIL 结构遍历数组。

3. Two-Dimensional Arrays | 二维数组

Two-dimensional arrays extend the concept to a grid of rows and columns. In OCR pseudocode, you may see DECLARE grid : ARRAY[0:2, 0:2] OF CHAR to represent a 3×3 grid. The first index is usually the row, and the second is the column.

二维数组将概念扩展到由行和列组成的网格。OCR 伪代码中可能出现 DECLARE grid : ARRAY[0:2, 0:2] OF CHAR 表示 3×3 网格。通常第一个索引表示行，第二个表示列。

To access an element, you write grid[1,2], which retrieves the value in the second row, third column (remember zero-indexing). This model is extremely useful for representing board games, spreadsheets, images, or adjacency matrices in graph theory.

访问元素时写作 grid[1,2]，即获取第二行、第三列的值（牢记零索引）。这一模型在棋盘游戏、电子表格、图像或图论中的邻接矩阵表示中极为有用。

When solving problems with 2D arrays, nested loops are the standard tool: the outer loop iterates over rows, and the inner loop over columns. OCR questions often ask you to write or trace code that processes 2D arrays, so practice nested iteration carefully.

求解二维数组问题时，嵌套循环是标准工具：外层循环遍历行，内层循环遍历列。OCR 试题常要求编写或追踪处理二维数组的代码，因此务必熟练嵌套迭代。

4. Array Indexing and Access | 数组索引与访问

Indexing is the mechanism that maps an integer key to a specific array cell. Because arrays use contiguous memory, the address of element i can be computed as: base address + (index × element size). This gives O(1) random access, making arrays extremely fast for reading and writing.

索引是将整数键映射到特定数组单元的机制。由于数组使用连续内存，元素 i 的地址可计算为：基地址 + (索引 × 元素大小)。这实现了 O(1) 随机访问，使数组的读写速度极快。

In OCR exam contexts, you will primarily work with integer indices. Always verify that an index lies within the declared bounds before accessing the element. Boundary checking is a key skill for robust algorithm design, and exam mark schemes often reward explicit validation.

在 OCR 考试环境中，你主要处理整数索引。访问元素前务必验证索引是否位于声明的边界内。边界检查是稳健算法设计的关键技能，阅卷标准通常奖励显式验证。

Remember that the last valid index is upper_bound - lower_bound if the array starts at 0. For an array declared as ARRAY[0:9], valid indices are 0 through 9 inclusive, giving 10 elements. Miscalculating length is a frequent source of errors in student scripts.

记住，若数组从 0 开始，最后一个有效索引为 上界 - 下界。对于声明为 ARRAY[0:9] 的数组，有效索引为 0 到 9（含），共 10 个元素。计算长度错误是考生答卷中常见的错误来源。

5. Traversing Arrays | 遍历数组

Traversal means visiting each element of an array exactly once, usually to read, update, or accumulate values. A FOR loop is the most natural choice for a full traversal because the number of iterations is known in advance.

遍历是指恰好访问数组的每个元素一次，通常用于读取、更新或累加数值。FOR 循环是最自然的全遍历选择，因为迭代次数事先已知。

Exam questions may ask you to perform conditional traversal, where only elements meeting certain criteria are processed. For example: ‘output all names longer than 5 characters’ or ‘count the number of negative numbers’. In such cases, integrate an IF statement inside the loop body.

考题可能要求条件遍历，即只处理满足特定条件的元素。例如：“输出所有长度超过 5 个字符的名字”或“计算负数的个数”。这时应在循环体内嵌入 IF 语句。

A common OCR task is to write a traversal that modifies the array in place, such as squaring each element or shifting values. When altering elements, be careful not to repeatedly use a freshly updated value unless the algorithm intends that. Always trace a few iterations to confirm correctness.

OCR 常见任务是编写原地修改数组的遍历代码，例如将每个元素平方或移动值。修改元素时，除非算法有意为之，否则不要重复使用刚刚更新的值。务必手动追踪几次循环以确认正确性。

FOR i ← 0 TO LEN(arr)-1
    IF arr[i] < 0 THEN
        arr[i] ← 0
    ENDIF
ENDFOR

上面的示例将数组中的所有负数替换为 0。伪代码中 LEN(arr) 返回元素个数。

6. Array Operations: Insertion | 数组操作：插入

Inserting a new element into an array requires shifting existing elements to make room. In a static array, you can only insert if there is unused space. The average and worst-case time complexity of insertion at an arbitrary position is O(n) because of the required shifts.

在数组中插入新元素需要移动现有元素以腾出空间。在静态数组中，只有存在未使用空间时才能插入。由于需要移位，在任意位置插入的平均和最坏时间复杂度均为 O(n)。

To insert a value at index pos, you first shift all elements from index pos to last one place to the right, then write the new value at pos, and finally increment the size counter. OCR pseudocode questions may ask you to implement this logic, so you must be clear about the direction of the shift: start from the last occupied index and move backwards.

在索引 pos 处插入值时，首先将索引 pos 至 last 的所有元素向右移动一位，然后在 pos 处写入新值，最后递增大小计数器。OCR 伪代码题可能要求你实现这一逻辑，因此必须清楚移位方向：从最后一个已占用索引开始，向后移动。

Consider an array of length 10 with 6 elements. To insert at index 2, elements at indices 5 down to 2 must each move to 6 down to 3. The correct loop is: FOR i ← last DOWNTO pos ensuring no data is overwritten prematurely.

假设一个长度为 10 的数组当前有 6 个元素。要在索引 2 处插入，索引 5 到 2 的元素需各自移至 6 到 3。正确的循环是：FOR i ← last DOWNTO pos，确保数据不会被提前覆盖。

Before insertion at index 2:	A, B, C, D, E, F, _, _, _, _
Shift right from end:	A, B, C, C, D, E, F, _, _, _ (copying C to pos 3 first would lose D)
Correct shift with DOWNTO:	Move F to 6, E to 5, D to 4, C to 3, then insert X at 2: A, B, X, C, D, E, F, _

This visualisation helps avoid the classic ‘overwrite before move’ mistake that mark schemes penalise heavily.

7. Array Operations: Deletion | 数组操作：删除

Deletion also involves shifting elements, but this time to close the gap. When removing the element at index pos, you shift all elements from pos+1 to last one place to the left. The last position is then cleared or ignored, and the size counter is decremented.

删除同样涉及元素移动，但这次是为了填补空缺。当移除索引 pos 处的元素时，将索引 pos+1 到 last 的所有元素向左移动一位。随后清除或忽略最后一个位置，并递减大小计数器。

The shifting loop for deletion runs forward: FOR i ← pos TO last-1 arr[i] ← arr[i+1]. This correctly overwrites the deleted element and pulls everything left. As with insertion, the time complexity is O(n) due to shifting.

删除的移位循环是正向的：FOR i ← pos TO last-1 arr[i] ← arr[i+1]。这会正确覆盖被删除元素并将后续元素左移。与插入一样，因移位导致时间复杂度为 O(n)。

OCR questions may ask you to delete all occurrences of a given value or to remove duplicates. Efficient approaches often involve two-pointer techniques, but for the exam, a clear, correct shifting algorithm with appropriate bounds is sufficient to gain full marks.

OCR 试题可能要求删除所有指定值或移除重复项。高效方法常涉及双指针技术，但在考试中，边界正确、思路清晰的移位算法即可获得满分。

8. Static vs Dynamic Arrays | 静态数组与动态数组

A static array has a fixed size determined at declaration time and cannot be resized. In OCR pseudocode, ARRAY[0:9] OF STRING creates a static array of 10 strings. If you need to store more than 10 items, you must declare a larger array and copy data, which is inefficient.

静态数组在声明时确定固定大小，无法调整。OCR 伪代码中，ARRAY[0:9] OF STRING 创建了一个可存 10 个字符串的静态数组。若需存储超过 10 个项，必须声明更大数组并复制数据，效率较低。

Dynamic arrays (often called lists in high-level languages) can grow or shrink as needed. While the underlying implementation may still use arrays, they provide abstracted resizing. In OCR exams, you may be told to assume a suitable list structure; be aware of typical operations like append, remove, or insert at position.

动态数组（高级语言中常称为列表）可按需增长或缩减。尽管底层实现仍可能使用数组，但它们提供了抽象的调整大小功能。OCR 考试中可能允许假设合适的列表结构；需熟悉 append、remove 或 insert at position 等典型操作。

Understand the trade-offs: static arrays offer predictable memory usage and constant-time access, while dynamic arrays introduce occasional resizing overhead. In algorithm analysis, amortised O(1) for append in dynamic arrays is often accepted, but the worst-case is O(n).

理解其权衡：静态数组提供可预测的内存占用和常量时间访问，而动态数组偶尔会引入调整大小的开销。在算法分析中，动态数组追加操作的均摊 O(1) 常被接受，但最坏情况仍为 O(n)。

9. Memory Representation | 内存表示

Arrays occupy a single continuous block of memory. If the base address of an integer array is B and each integer occupies 4 bytes, the address of the element at index i is B + i × 4. This simple arithmetic allows O(1) direct access.

数组占用一块连续的内存。若一个整数数组的基地址为 B，每个整数占 4 字节，则索引 i 处元素的地址为 B + i × 4。这一简单计算实现了 O(1) 直接访问。

In OCR exams, you may be given a memory address problem: “An array starts at address 8000. Each element is 8 bytes. What is the address of the element at index 12?” The answer is 8000 + 12 × 8 = 8096. Be comfortable with such address arithmetic.

OCR 考试可能给出内存地址计算题：“某数组起始地址为 8000，每个元素占 8 字节。索引 12 处元素的地址是多少？”答案是 8000 + 12 × 8 = 8096。你应熟练掌握此类地址运算。

Two-dimensional arrays can be stored in row-major or column-major order. OCR typically assumes row-major order: all elements of the first row are stored consecutively, followed by the second row, and so on. The address for grid[i,j] is base + (i × number_of_columns + j) × element_size.

二维数组可按行优先或列优先顺序存储。OCR 通常假设行优先顺序：第一行的所有元素连续存放，然后是第二行，依此类推。grid[i,j] 的地址为：基地址 + (i × 列数 + j) × 元素大小。

10. Searching Algorithms with Arrays | 使用数组的搜索算法

Linear search scans each element in turn until the target is found or the end is reached. It works on unsorted arrays and has O(n) time complexity. OCR expects you to write and trace linear search pseudocode, often within larger scenarios.

线性搜索依次检查每个元素，直至找到目标或到达末尾。它适用于未排序数组，时间复杂度为 O(n)。OCR 要求你能够编写并追踪线性搜索伪代码，通常出现在更广泛的场景中。

Binary search is much faster, O(log n), but requires the array to be sorted. The algorithm compares the middle element with the target and halves the search interval. You must be precise about updating low and high pointers and calculating mid as low + (high - low) DIV 2 to avoid overflow (though OCR pseudocode may use integer division).

二分搜索速度快得多，为 O(log n)，但要求数组已排序。算法将中间元素与目标比较，并折半搜索区间。你必须精确更新 low 和 high 指针，并使用 low + (high - low) DIV 2 计算中间位置以避免溢出（OCR 伪代码可能直接用整除）。

A classic OCR question asks: “Explain why binary search requires a sorted array.” The answer lies in the logic of discarding the irrelevant half—without sorting, you cannot guarantee that the target is not in the discarded portion.

OCR 经典问题是：“解释为什么二分搜索要求数组有序。”答案在于抛弃不相关一半的逻辑——若不排序，无法保证目标不在被抛弃的部分中。

low ← 0
high ← LEN(arr)-1
WHILE low <= high
    mid ← (low + high) DIV 2
    IF arr[mid] == target THEN
        RETURN mid
    ELSE IF arr[mid] < target THEN
        low ← mid + 1
    ELSE
        high ← mid - 1
    ENDIF
ENDWHILE
RETURN -1   // not found

注意边界条件和循环终止条件，这是经常失分的地方。

11. Sorting Basics and Arrays | 排序基础与数组

The OCR syllabus expects you to understand at least one sorting algorithm, typically bubble sort, and to analyse its performance on arrays. Bubble sort repeatedly passes through the array, comparing adjacent items and swapping them if they are out of order.

OCR 课程要求你至少理解一种排序算法，通常是冒泡排序，并分析其在数组上的性能。冒泡排序反复遍历数组，比较相邻项并在顺序错误时交换它们。

Bubble sort has O(n²) time complexity in the worst and average cases. In OCR exams, you may be asked to trace a bubble sort on a small array or to write improved versions, such as stopping early if no swaps occur in a pass. This demonstrates understanding of algorithm efficiency.

冒泡排序在最坏和平均情况下时间复杂度为 O(n²)。OCR 考试可能要求就一个小数组追踪冒泡排序，或编写改进版本，例如若某趟未发生交换则提前终止。这体现了对算法效率的理解。

Although more advanced sorts like merge sort and quicksort are covered in other topics, recognising that sorting enables efficient search operations (like binary search) is vital. Arrays serve as the fundamental storage for all these sorting implementations.

尽管归并排序和快速排序等更高级排序在其他主题中涉及，但认识到排序能实现高效搜索操作（如二分搜索）至关重要。数组是所有排序实现的基本存储结构。

12. Exam Tips and Common Mistakes | 考试技巧与常见错误

Always check your index bounds. OCR examiners penalise array index out of range errors severely. When writing iterative algorithms, verify that the loop variable never exceeds UBOUND(arr) or goes below zero. Pay special attention to edge cases: empty arrays, single-element arrays, and arrays where all values are the same.

务必检查索引边界。OCR 考官对数组索引越界错误扣分很重。编写迭代算法时，核实循环变量不会超过 UBOUND(arr) 或低于零。特别注意边缘情况：空数组、单元素数组以及所有值相同的数组。

Use clear variable names and consistent pseudocode. In OCR paper, DECLARE, OUTPUT, INPUT, LEN are standard. Avoid mixing Python-specific syntax unless the question explicitly permits it. Commenting your pseudocode with brief explanations can help the examiner follow your logic, even if comments are not mandatory.

使用清晰的变量名和一致的伪代码。OCR 试卷中，DECLARE、OUTPUT、INPUT、LEN 是标准用词。除非题目明确允许，否则不要混用 Python 特有语法。虽然注释并非强制，但在伪代码中添加简要说明有助于阅卷人理解你的逻辑。

When tracing, do not rush. Write out the array state after each iteration. Many marks are lost because candidates miscount indices or forget to increment counters. Double-check shift directions in insertion and deletion—the safest mental check is to trace with a tiny array of two or three elements.

进行追踪时不要急躁。迭代后写出数组状态。许多失分是由于考生数错索引或忘记递增计数器。在插入和删除操作中再次检查移位方向——最安全的心理验证是用只有两三个元素的小数组进行追踪。

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

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

Array Exam Essentials for A-Level OCR Computer Science | A-Level OCR 计算机：数组 考点精讲