📚 Data Structures for GCSE OCR Computer Science | GCSE OCR 计算机：数据结构 考点精讲
Welcome to this comprehensive revision guide on data structures, tailored for the OCR GCSE Computer Science specification. Whether you’re grappling with the static nature of arrays, the dynamic flexibility of lists, the LIFO logic of stacks, the FIFO discipline of queues, or the hierarchical organisation of trees, this article breaks down every concept you need. We’ll explore how data structures are implemented, their advantages and limitations, and, crucially, how to trace, apply, and evaluate them in exam scenarios. By linking theory to pseudocode examples and real-world use cases, this guide ensures you can confidently answer any question on data structures, from simple definitions to complex algorithm tracing.
欢迎阅读这篇针对 OCR GCSE 计算机科学课程的数据结构全面复习指南。无论你是在纠结数组的静态特性、列表的动态灵活性、栈的后进先出逻辑、队列的先进先出规则，还是树的层级组织方式，本文都会逐一拆解所有必备概念。我们将探讨数据结构如何实现、它们的优点与局限，更重要的是，如何在考试场景中追踪、应用和评估它们。通过将理论与伪代码实例以及现实世界的应用案例相结合，这篇指南将确保你能自信地回答任何数据结构相关的问题——从简单的定义到复杂的算法追踪。
1. What Are Data Structures? | 什么是数据结构？
Data structures are specialised formats for organising, storing, and managing data so that it can be accessed and modified efficiently. In computer science, choosing the right data structure directly impacts the performance and clarity of algorithms. At GCSE level, you need to understand both static structures (like arrays) and dynamic structures (like lists), along with abstract data types such as stacks, queues, and trees. Each structure has specific rules for how data enters and leaves, which determines its suitability for different computational tasks.
数据结构是用于组织、存储和管理数据的专用格式，以便高效地访问和修改数据。在计算机科学中，选择正确的数据结构直接影响算法的性能和清晰度。在 GCSE 阶段，你需要理解静态结构（如数组）和动态结构（如列表），以及抽象数据类型，比如栈、队列和树。每种结构都有数据输入和离开的特定规则，这决定了它适用于不同的计算任务。
A key exam skill is being able to identify the most appropriate data structure for a given scenario. For instance, an array works well when the number of elements is fixed and known in advance, while a list is preferable when the collection needs to grow or shrink frequently. Stacks are ideal for undo features or backtracking, queues for print spoolers or task scheduling, and binary trees for efficient searching. You must also be able to trace operations step by step, showing the state of a structure after each push, pop, enqueue, or dequeue.
一项关键的考试技能是能够根据给定的场景识别出最合适的数据结构。例如，当元素数量固定且提前已知时，数组是不错的选择；而当集合需要频繁增减时，列表更合适。栈非常适合实现撤销功能或回溯操作；队列适用于打印缓冲池或任务调度；而二叉树则用于高效搜索。你还必须能逐步追踪操作过程，展示每次压入、弹出、入队或出队后数据结构的状态。
2. Arrays: The Foundation | 数组：基础基石
An array is a static, contiguous block of memory that holds a fixed number of elements, all of the same data type. Each element is accessed directly via an integer index, typically starting at 0. Because the memory allocation is static, the size of an array must be declared in advance and cannot be changed at runtime. This means inserting or deleting elements is inefficient, as it may require shifting elements or creating a new array altogether. However, direct access by index gives arrays a time complexity of O(1) for reading or writing any element, making them extremely fast for random access.
数组是一块静态、连续的内存区域，用于存放固定数量的元素，且所有元素必须为同一数据类型。每个元素通过整数索引（通常从 0 开始）直接访问。由于内存分配是静态的，数组的大小必须预先声明，且运行时不可更改。这意味着插入或删除元素效率低下，因为可能需要移动元素甚至创建新数组。不过，通过索引直接访问使得数组读取或写入任何元素的时间复杂度为 O(1)，这让它在随机访问方面速度极快。
In OCR exam questions, you might be asked to write pseudocode that uses an array to store, say, the names of students in a class of 30. You would declare it as array students[30] and then assign values like students[0] = “Alice”. A common pitfall is referencing an index out of bounds, which causes a runtime error. Additionally, you should be aware of two-dimensional arrays, which function like a table or grid. For example, a 2D array grid[3][3] can represent a tic-tac-toe board, with rows and columns accessed via grid[row][col].
在 OCR 的考试题目中，你可能会被要求编写伪代码，用数组存储例如一个 30 人班级的学生姓名。你需要将其声明为 array students[30]，然后赋值，如 students[0] = “Alice”。一个常见的易错点是引用了越界的索引，这会导致运行时错误。此外，你还应了解二维数组，它的功能类似表格或网格。例如，二维数组 grid[3][3] 可以表示一个井字棋棋盘，通过 grid[row][col] 访问行和列。
3. Lists: Dynamic and Flexible | 列表：动态灵活
Unlike arrays, lists are dynamic data structures that can grow and shrink as needed. In many programming languages, a list is implemented as a collection that automatically resizes when elements are added or removed. This flexibility comes with a trade-off: accessing an element by index is still fast, but operations like inserting or deleting in the middle of the list may require shifting elements, which can be slower than in an array for very large datasets. However, the ability to add and remove items without predefining a size makes lists the go-to structure for many everyday programming tasks.
与数组不同，列表是一种动态数据结构，可以根据需要增长和收缩。在许多编程语言中，列表实现为一个集合，能在添加或删除元素时自动调整大小。这种灵活性是有代价的：通过索引访问元素仍然很快，但在列表中间插入或删除元素可能需要移动其他元素，对于非常大的数据集，这可能比数组更慢。然而，无需预先定义大小即可添加和删除项的能力，使得列表成为许多日常编程任务的首选结构。
For OCR GCSE, you need to understand typical list methods such as append(item), remove(item), insert(index, item), and length(). In pseudocode, you might see a list being built up inside a loop: while input != “end”, mylist.append(input). Be prepared to trace code that iterates through a list and performs conditional checks. For example, you could be asked to identify which values are printed when a algorithm searches through a list of numbers for all values greater than 10. The dynamic nature of lists also means you should consider memory management: repeatedly adding items can lead to occasional resizing operations behind the scenes.
对于 OCR GCSE，你需要理解典型的列表方法，如 append(item)（追加）、remove(item)（移除）、insert(index, item)（插入）和 length()（长度）。在伪代码中，你可能会看到列表在循环中被构建：while input != “end”，mylist.append(input)。要准备好追踪遍历列表并进行条件检查的代码。例如，你可能会被要求找出当算法在数字列表中搜索所有大于 10 的值时，会打印出哪些值。列表的动态特性也意味着你应该考虑内存管理：反复添加项可能会导致在后台偶尔进行大小调整操作。
4. Stacks: LIFO in Action | 栈：后进先出的实践
A stack is an abstract data type that follows the Last In, First Out (LIFO) principle. Imagine a stack of plates: you can only take the top plate, and you can only add a new plate to the top. The two fundamental operations are push (add an item to the top) and pop (remove and return the top item). Additionally, a peek operation may return the top item without removing it. Stacks are often used for managing function calls (call stack), undo mechanisms in software, and for parsing expressions or backtracking algorithms.
栈是一种遵循后进先出（LIFO）原则的抽象数据类型。想象一叠盘子：你只能取最上面的盘子，也只能把新盘子放在最上面。两个基本操作是 push（将一个项压入栈顶）和 pop（移除并返回栈顶项）。此外，还可以有 peek 操作，它返回栈顶项但不移除它。栈通常用于管理函数调用（调用栈）、软件中的撤销机制，以及解析表达式或回溯算法。
In the OCR exam, you are very likely to be asked to trace a sequence of stack operations. You must show the contents of the stack after each step, often drawn vertically. For instance, starting with an empty stack, push(5), push(3), pop(), push(7) results in the stack containing [5, 7] where 7 is the top. When writing pseudocode to implement a stack, you could use an array and a pointer (often called top) to track the index of the most recently added element. Watch out for stack overflow (trying to push onto a full stack) and stack underflow (trying to pop from an empty stack) errors.
在 OCR 考试中，你极有可能被要求追踪一系列栈操作。你必须展示每一步之后栈中的内容，通常以垂直方式绘制。例如，从一个空栈开始，执行 push(5), push(3), pop(), push(7) 后，栈将包含 [5, 7]，其中 7 是栈顶。在编写实现栈的伪代码时，你可以使用一个数组和一个指针（通常称为 top）来跟踪最近添加元素的索引。要当心栈溢出（试图向已满的栈压入）和栈下溢（试图从空栈中弹出）错误。
5. Queues: FIFO Disciplined | 队列：先进先出的纪律
A queue is an abstract data type that operates on a First In, First Out (FIFO) basis. Think of a line at a ticket counter: the first person to join the queue is the first to be served. The core operations are enqueue (add an item to the rear) and dequeue (remove and return the item from the front). Queues are essential for scheduling processes in operating systems, managing print jobs, and handling data in communication buffers. They ensure fairness and sequential processing.
队列是一种基于先进先出（FIFO）原则运行的抽象数据类型。想象售票柜台前的一排队伍：第一个加入队列的人第一个被服务。核心操作是 enqueue（将一个项加入队尾）和 dequeue（从队首移除并返回该项）。队列对于操作系统中的进程调度、管理打印作业以及处理通信缓冲区中的数据至关重要。它们确保了公平性和顺序处理。
Linear queues can be implemented with an array and two pointers, front and rear. However, as items are dequeued, the front moves forward, leaving empty spaces at the beginning that cannot be reused. This leads to a circular queue design, where the pointers wrap around to the start of the array when they reach the end. The exam might ask you to calculate the next position using modulo arithmetic: rear = (rear + 1) MOD maxSize. You should be able to distinguish between full and empty conditions in a circular queue—typically, the queue is full when the next rear position equals the front.
线性队列可以用一个数组和两个指针 front（队首）和 rear（队尾）来实现。然而，当项目出队时，队首向前移动，导致队列开头留下无法重用的空位。这催生了循环队列设计，即指针到达数组末尾时会绕回开头。考试可能会要求你使用模运算来计算下一个位置：rear = (rear + 1) MOD maxSize。你应当能够区分循环队列中的满状态和空状态——通常，当下一个队尾位置等于队首位置时，队列为满。
6. Arrays vs. Lists: Exam Comparison | 数组与列表：考试对比
Comparing arrays and lists is a staple of OCR GCSE exams. The primary difference lies in their mutability of size. An array has a static size, meaning memory is allocated once and cannot be altered. A list, however, is dynamic, allowing the addition and removal of elements without redefining the structure. Arrays are generally more memory-efficient when the number of elements is known and constant, because they avoid the overhead of dynamic resizing. Lists, on the other hand, provide greater convenience and are less error-prone when dealing with variable-length collections.
比较数组和列表是 OCR GCSE 考试中的常客。主要区别在于大小是否可变。数组的大小是静态的，意味着内存只分配一次且不可更改。而列表是动态的，允许在不重新定义结构的情况下添加和删除元素。当元素数量已知且固定时，数组通常更节省内存，因为它们避免了动态调整大小的开销。另一方面，列表在需要处理长度可变的集合时，提供了更大的便利性，且更不容易出错。
In pseudocode, you might need to decide which structure to use based on the problem. If the specification says “store exactly 20 temperature readings”, an array is perfect. If it says “store an unknown number of user inputs until ‘quit’ is entered”, a list is necessary. You may also be asked about the consequences of choosing the wrong structure, such as wasted memory (array too large) or runtime errors (array too small). A simple comparison table can help consolidate these points:
在伪代码中，你可能需要根据问题来决定使用哪种结构。如果题目说“存储恰好 20 个温度读数”，数组就是完美的选择。如果题目说“存储未知数量的用户输入，直到输入 ‘quit’”，那么列表就必不可少。你也可能被问到选择错误结构的后果，例如内存浪费（数组过大）或运行时错误（数组过小）。一个简单的对比表有助于巩固这些要点：
| Feature |
Array |
List |
| Size |
Static (fixed) |
Dynamic (resizable) |
| Memory allocation |
Contiguous block |
Non-contiguous possible |
| Element access |
Direct via index O(1) |
Direct via index O(1) |
| Insert/delete at end |
Not allowed (fixed size) |
Efficient (amortised O(1)) |
| Insert/delete in middle |
Inefficient (shift elements) |
Inefficient (shift elements) |
特征
数组
列表
大小
静态（固定）
动态（可调节）
内存分配
连续内存块
可能非连续
元素访问
通过索引直接访问 O(1)
通过索引直接访问 O(1)
在末尾插入/删除
不允许（大小固定）
高效（均摊 O(1)）
在中间插入/删除
低效（需移动元素）
低效（需移动元素）
Remember that in OCR pseudocode, arrays are often 0-indexed and declared with a size, while lists are simply created and elements added via a method. Always read the question carefully to determine which structure is assumed.
请记住，在 OCR 伪代码中，数组通常采用 0 起始索引并声明大小，而列表则直接创建并通过方法添加元素。务必仔细读题，以确定题目假定使用哪种结构。
7. Stacks vs. Queues: LIFO vs. FIFO | 栈与队列：LIFO 与 FIFO
Although both stacks and queues are linear abstract data types, their operational principles are polar opposites. A stack uses LIFO, meaning the most recently added element is the first to be removed. This makes it perfect for depth-first traversal, reverse-order processing, or undo operations. A queue uses FIFO, where the earliest added element is the first to be removed. This is suited for breadth-first traversal, fair scheduling, and buffering.
虽然栈和队列都是线性抽象数据类型，但它们的工作原理截然相反。栈采用 LIFO，即最后添加的元素最先被移除。这使其非常适合深度优先遍历、逆序处理或撤销操作。队列则采用 FIFO，即最早添加的元素最先被移除。这适合于广度优先遍历、公平调度和缓冲处理。
In the exam, a typical question provides a series of operations and asks for the final state of either a stack or a queue. For example, with an empty queue, enqueue(A), enqueue(B), dequeue(), enqueue(C) leaves the queue as [B, C] where B is at the front. Compare this to a stack: push(A), push(B), pop(), push(C) results in [A, C] with C on top. Visualising the structure with a labelled diagram can prevent silly mistakes. Another common exercise is to match real-world scenarios to the correct structure: a call stack uses a stack, a printer spooler uses a queue.
在考试中，典型的题目会给出系列操作，要求写出栈或队列的最终状态。例如，对一个空队列执行 enqueue(A), enqueue(B), dequeue(), enqueue(C) 后，队列变为 [B, C]，其中 B 位于队首。与此对比，栈的操作：push(A), push(B), pop(), push(C) 会得到 [A, C]，C 在栈顶。用带标签的图表进行可视化可以避免愚蠢的错误。另一个常见的练习是将现实场景与正确的结构进行匹配：调用栈使用栈，打印缓冲池使用队列。
Understanding these differences also ties into algorithm design. For instance, checking for balanced parentheses in an expression uses a stack: push on ‘(‘, pop on ‘)’. If the stack is empty at the end, the parentheses are balanced. A queue, by contrast, cannot solve this problem because the order of removal would not match the nesting order. Always ask yourself: does the order of processing matter in reverse or in the original insertion order?
理解这些差异也与算法设计息息相关。例如，检查表达式中的括号是否匹配会用到栈：遇到 ‘(‘ 压入，遇到 ‘)’ 弹出。如果最后栈空，则括号匹配。而队列无法解决此问题，因为移除的顺序与嵌套顺序不匹配。永远要问自己：处理顺序是逆序还是按原始插入顺序？
8. Records: Composite Data | 记录：复合数据
A record is a data structure that groups together related items of possibly different data types into a single unit. Each item is called a field, and each field has a name and a type. Records are fundamental to database systems and object-oriented programming. For example, a student record might contain fields: name (string), age (integer), grade (character). Unlike an array, which stores homogeneous data, a record stores heterogeneous data, giving it a more descriptive structure.
记录是一种数据结构，它将可能具有不同数据类型、但互相关联的项组合成一个单元。每个项称为一个字段，每个字段都有一个名称和一个类型。记录是数据库系统和面向对象编程的基础。例如，一个学生记录可能包含字段：name（字符串）、age（整数）、grade（字符）。与存储同类数据的数组不同，记录存储的是异类数据，这使其具有更强的描述性结构。
In OCR pseudocode, you might see records defined using a structure similar to Python dictionaries, or with a specific keyword like RECORD. For instance:
RECORD Student
name : STRING
age : INTEGER
ENDRECORD
You then create an instance and assign values to fields: student1.name = “Alice”. When dealing with multiple records, they are often stored in an array or list of records. You should be comfortable iterating through a list of records and accessing specific fields. Questions may ask you to write an algorithm that finds the highest age among all students, or to output the names of students with a grade ‘A’.
在 OCR 伪代码中，你可能会看到使用类似于 Python 字典的结构来定义记录，或者使用像 RECORD 这样的特定关键字。例如：
RECORD Student
name : STRING
age : INTEGER
ENDRECORD
然后你创建一个实例并为字段赋值：student1.name = “Alice”。当处理多条记录时，它们通常被存储在数组或列表的记录中。你应当能熟练地遍历记录列表并访问特定字段。问题可能会要求你编写一个算法，找出所有学生中的最高年龄，或者输出成绩为 ‘A’ 的学生姓名。
9. Introduction to Trees: Hierarchical Data | 树简介：层级数据
A tree is a non-linear, hierarchical data structure consisting of nodes connected by edges. The topmost node is called the root, and every other node is a child of some parent node. Nodes with no children are leaves. Trees are used to represent hierarchical relationships, such as file systems, organisation charts, and the document object model (DOM) in web pages. A specialised version, the binary tree, restricts each node to at most two children, often referred to as left and right child.
树是一种非线性的、层级式的数据结构，由通过边连接的节点组成。最顶端的节点称为根节点，其他每个节点都是某个父节点的子节点。没有子节点的节点被称为叶节点。树用于表示层级关系，例如文件系统、组织结构图以及网页中的文档对象模型（DOM）。一种特殊的版本——二叉树，限制每个节点最多有两个子节点，通常称为左子节点和右子节点。
At GCSE, your focus will mainly be on binary trees and their traversal. You need to understand how nodes are organised: each node contains data and pointers (references) to its children. A node structure might be represented as:
Node: {data, left, right}
Traversal means visiting every node systematically. The three common depth-first traversals are pre-order (root, left, right), in-order (left, root, right), and post-order (left, right, root). In-order traversal of a binary search tree visits nodes in ascending order. You might be given a tree diagram and asked to state the output of a specific traversal, or to complete a partially given traversal sequence. Use the mnemonic: Pre – root first; In – root in the middle; Post – root last.
在 GCSE 阶段，你的重点将主要放在二叉树及其遍历上。你需要理解节点如何组织：每个节点包含数据以及指向其子节点的指针（引用）。节点结构可能表示为：
Node: {data, left, right}
遍历意味着系统地访问每一个节点。三种常见的深度优先遍历是：前序（根、左、右）、中序（左、根、右）和后序（左、右、根）。对二叉搜索树进行中序遍历会按升序访问节点。你可能遇到给出一棵树的图示，要求写出特定遍历的输出结果，或者补全部分给出的遍历序列。记住口诀：Pre（前序）——根最先；In（中序）——根在中间；Post（后序）——根最后。
10. Binary Search Trees: Efficient Search | 二叉搜索树：高效搜索
A binary search tree (BST) is a binary tree with an ordering property: for any node, all nodes in its left subtree have values less than the node’s value, and all nodes in its right subtree have values greater. This organisation allows for extremely efficient searching, insertion, and deletion—in the best case O(log n)—by repeatedly halving the search space. The BST is a cornerstone of database indexing and auto-complete features.
二叉搜索树（BST）是一种具有排序属性的二叉树：对于任意节点，其左子树中所有节点的值都小于该节点的值，而其右子树中所有节点的值都大于该节点的值。这种组织方式通过反复将搜索空间减半，实现了极其高效的搜索、插入和删除——最佳情况为 O(log n)。二叉搜索树是数据库索引和自动补全功能的基石。
To search in a BST, you start at the root. If the target equals the root, you’re done. If the target is less, move to the left child; if greater, move to the right. Repeat until found or a leaf is reached. In the OCR exam, you might be asked to insert a sequence of numbers into an initially empty BST and draw the resulting tree. For example, inserting 8, 3, 10, 1, 6 builds a tree where 8 is root, 3 is left of 8, 10 right of 8, 1 left of 3, and 6 right of 3. Deleting a node is trickier; you may need to find the in-order successor (the smallest node in the right subtree) to replace a deleted node with two children.
在二叉搜索树中搜索时，从根节点开始。如果目标值等于根节点，则完成。如果目标值更小，则移到左子节点；如果更大，则移到右子节点。重复此过程直至找到或到达叶节点。在 OCR 考试中，你可能会被要求将一串数字插入一个初始为空的二叉搜索树，并画出最终生成的树。例如，依次插入 8, 3, 10, 1, 6 会构建出一棵树，其中 8 为根，3 位于 8 的左侧，10 位于右侧，1 是 3 的左子，6 是 3 的右子。删除节点更复杂一些；如果要删除的节点有两个子节点，你可能需要找到中序后继节点（右子树中最小的节点）来替换它。
Be aware of the problem of unbalanced trees. If you insert already sorted data, the BST degenerates into a linked list, making searches O(n). In an exam, you might be asked to explain why a particular BST is inefficient and how to improve it (by inserting data in a different order, or using a self-balancing tree, though the latter is beyond GCSE scope). Understanding this limitation demonstrates deeper insight.
要注意不平衡树的问题。如果你插入的是已排好序的数据，二叉搜索树会退化成一条链表，使得搜索复杂度变为 O(n)。在考试中，你可能会被要求解释为什么某棵特定的二叉搜索树效率低，以及如何改进（通过改变插入顺序，或使用自平衡树，虽然后者超出了 GCSE 范围）。理解这一局限能体现出更深刻的洞察力。
11. Storing Data Structures: Practical Programming | 数据结构的存储：编程实战
In a practical programming context, data structures are stored in the computer’s memory either statically (on the stack) or dynamically (on the heap). Arrays are typically stored in a contiguous block of memory, making them cache-friendly. Lists, depending on the implementation, may use arrays under the hood (like Python’s list) or linked nodes (linked list). A linked list is a dynamic structure where each element (node) contains data and a pointer to the next node; insertion and deletion are efficient at any point because no shifting is required, but direct index access is slower (O(n)).
在实际编程语境中，数据结构存储在计算机内存中，可以静态存储（在栈上）或动态存储（在堆上）。数组通常存储在连续的内存块中，这使它们对缓存友好。根据具体实现，列表的底层可能使用数组（如 Python 的 list）或链接节点（链表）。链表是一种动态结构，其中每个元素（节点）包含数据和一个指向下一个节点的指针；由于不需要移动元素，在任何位置进行插入和删除都很高效，但直接通过索引访问较慢（O(n)）。
Although linked lists are not specifically mandated in the OCR specification, you should understand the difference between array-based and pointer-based implementations. For stacks and queues, you can implement them using either arrays (with pointers) or linked lists. The choice affects memory usage and performance. For instance, an array-based stack may need to be predefined with a maximum size, risking overflow, while a linked list stack can grow indefinitely (subject to total memory). The exam may ask you to evaluate the appropriateness of an implementation method.
尽管 OCR 考纲并未明确要求掌握链表，但你应当理解基于数组和基于指针的实现之间的区别。对于栈和队列，你可以使用数组（配合指针）或链表来实现。选择会影响内存使用和性能。例如，基于数组的栈可能需要预先定义最大大小，存在溢出风险，而基于链表的栈可以无限增长（受限于总内存）。考试可能会要求你评估某种实现方法的适宜性。
When writing pseudocode, always be mindful of initialisation. A stack implemented with an array needs a top pointer initially set to -1 (empty). A queue needs front and rear pointers set appropriately. For a BST, node creation involves assigning left and right pointers to null. These details are crucial for securing marks on algorithm questions.
在编写伪代码时，务必留意初始化。用数组实现的栈需要一个初始设为 -1（空）的栈顶指针。队列需要适当地设置队首和队尾指针。对于二叉搜索树，创建节点时需要将左右指针设为 null。这些细节对于在算法题中拿分至关重要。
12. Exam-Style Questions and Tips | 考试风格问题与技巧
To excel in OCR GCSE data structures questions, you must master three key skills: recognition (identifying the structure from a description or code), tracing (simulating operations step by step), and evaluation (comparing structures for a given scenario). Common question formats include filling in the blanks in a stack or queue trace table, drawing a tree after a series of insertions, writing pseudocode to traverse a 2D array, and explaining why a list is more suitable than an array for storing user inputs.
想要在 OCR GCSE 的数据结构题目中取得优异成绩，你必须掌握三项关键技能：识别（根据描述或代码辨别数据结构）、追踪（逐步模拟操作）和评估（针对特定场景比较不同结构）。常见的题型包括：填写栈或队列追踪表中的空白、画出一系列插入操作后的树、编写遍历二维数组的伪代码，以及解释为何存储用户输入时列表比数组更合适。
Here are some exam tips: always show your working when tracing—even if the final state is wrong, intermediate steps can earn marks. Label your diagrams clearly with node values and pointers. Use the correct terminology: for stacks it’s push/pop, for queues it’s enqueue/dequeue. When comparing, structure your answer with clear points: memory usage, speed of access, ease of modification. Practise past paper questions under timed conditions, and create your own mini quizzes mixing arrays, lists, stacks, queues, and trees.
以下是一些考试技巧：追踪时务必展示你的推导过程——即使最终状态错误，中间步骤也可能得分。在图表中清晰地标注节点值和指针。使用正确的术语：栈用 push/pop，队列用 enqueue/dequeue。比较时，用清晰的观点组织答案：内存使用、访问速度、修改的便捷性。在计时条件下练习历年真题，并自己创建融合数组、列表、栈、队列和树的小测验。
Finally, remember that data structures are not isolated topics. They underpin searching and sorting algorithms (binary search on arrays, tree sort, etc.), and they appear in programming projects where you need to manage collections of data. Relating abstract structures to tangible applications will cement your understanding and boost your confidence on exam day.
最后，请记住数据结构并非孤立的知识点。它们支撑着搜索和排序算法（在数组上的二分查找、树排序等），并且出现在需要管理数据集合的编程项目中。将抽象的结构与实际应用联系起来，将巩固你的理解，并在考试当天增强你的信心。
Published
Published by TutorHao | GCSE Computer Science Revision Series | aleveler.com
更多咨询请联系16621398022（同微信）