Mastering Algorithms for GCSE AQA Mathematics | GCSE AQA 数学：算法考点精讲

📚 Mastering Algorithms for GCSE AQA Mathematics | GCSE AQA 数学：算法考点精讲

Algorithms form a core part of the GCSE AQA Mathematics specification, blending logical thinking with structured problem solving. An algorithm is simply a step-by-step set of instructions designed to perform a specific task or solve a problem. In this topic, you will encounter flowcharts, pseudocode, and standard searching and sorting algorithms such as linear search, binary search, bubble sort, and merge sort. Understanding how these work and being able to trace them by hand are essential skills for the exam. This revision guide walks you through every key concept, provides clear explanations, and highlights common pitfalls so you can approach algorithm questions with confidence.

算法是 GCSE AQA 数学大纲的核心内容之一，它融合了逻辑思维与结构化的问题解决方法。算法就是为完成特定任务或解决问题而设计的一系列分步指令。在本主题中，你将接触到流程图、伪代码以及标准的搜索和排序算法，例如线性搜索、二分搜索、冒泡排序和归并排序。理解这些算法的工作原理并能够手动追踪它们是考试的基本技能。本复习指南将带你梳理每一个关键概念，提供清晰的解释，并指出常见误区，让你能自信应对算法类题目。

1. What is an Algorithm? | 什么是算法？

An algorithm is a finite sequence of well-defined instructions used to solve a problem or complete a computation. In GCSE Mathematics, algorithms are often presented as sets of operations applied to numbers, lists, or data. A correct algorithm must be unambiguous, have a clear stopping condition, and produce the intended output for all valid inputs. Everyday examples include recipes, assembly instructions, and even the steps you follow to solve an equation.

算法是用于解决问题或完成计算的一组有限且明确的指令序列。在 GCSE 数学中，算法通常表现为应用于数字、列表或数据的一系列操作。一个正确的算法必须清晰无歧义，有明确的终止条件，并对所有有效输入都能产生预期的输出。日常生活中的例子包括食谱、组装说明书，甚至是你解方程时所遵循的步骤。

Key properties of an algorithm include finiteness (it always terminates), definiteness (each step is precisely stated), input (zero or more inputs), output (at least one output), and effectiveness (steps are simple enough to be carried out). When designing or analysing an algorithm, you must ensure it does not get stuck in an infinite loop and that every possible path through the logic leads to a conclusion.

算法的关键特性包括有限性（总会终止）、确定性（每步都精确陈述）、输入（零个或多个输入）、输出（至少一个输出）和可行性（步骤足够简单，可以执行）。在设计或分析算法时，必须确保它不会陷入无限循环，并且逻辑中的每一条可能路径都能导向一个结论。

2. Representing Algorithms: Flowcharts and Pseudocode | 算法的表示：流程图与伪代码

Algorithms can be communicated using flowcharts or pseudocode. A flowchart uses standard symbols: ovals for start and end, rectangles for processes, diamonds for decisions, and arrows to show the flow of control. Flowcharts give a visual overview of the algorithm’s structure, making it easy to identify loops and conditional branches. In the exam, you may be asked to interpret a given flowchart or to draw one for a simple process.

算法可以通过流程图或伪代码来呈现。流程图使用标准符号：椭圆表示开始和结束，矩形表示处理过程，菱形表示判断，箭头表示控制流向。流程图直观地展示了算法的结构，便于识别循环和条件分支。在考试中，你可能会被要求解读给定的流程图，或为某个简单过程绘制流程图。

Pseudocode is a written description of an algorithm that resembles simplified programming code. It uses keywords such as INPUT, OUTPUT, FOR, WHILE, IF…THEN…ELSE, and assignment arrows (←). Pseudocode is not a real programming language, so you do not need to worry about exact syntax; the emphasis is on logical clarity. For example, a pseudocode to find the largest of two numbers could be written as:

伪代码是一种书面的算法描述，类似于简化的编程代码。它使用诸如 INPUT、OUTPUT、FOR、WHILE、IF…THEN…ELSE 等关键词和赋值箭头（←）。伪代码不是真实的编程语言，因此你无需担心精确的语法；重点在于逻辑清晰。例如，找出两个数中较大者的伪代码可以写为：

INPUT A, B
IF A > B THEN
OUTPUT A
ELSE
OUTPUT B
ENDIF

Both flowcharts and pseudocode are acceptable in the AQA exam, and you should be comfortable converting between them.

流程图和伪代码在 AQA 考试中都是可接受的，你应当能轻松地在两者之间转换。

3. Linear Search | 线性搜索

A linear search algorithm checks each item in a list one by one until the target value is found or the end of the list is reached. It works on both sorted and unsorted lists. The steps are straightforward: start at the first element, compare it with the target, and if they match, stop and output the position; otherwise, move to the next element. If the entire list is scanned without finding the target, the algorithm reports that the item is not present.

线性搜索算法逐一检查列表中的每一项，直到找到目标值或到达列表末尾。它适用于已排序和未排序的列表。步骤很简单：从第一个元素开始，将其与目标值比较，如果匹配就停止并输出位置；否则移至下一个元素。如果扫描了整个列表仍未找到目标，算法就报告该项不存在。

For a list of n items, the worst-case scenario is that the target is at the very end or not present, requiring n comparisons. Hence, linear search has a time complexity of O(n). Although it is simple to implement, it becomes inefficient for very large lists. In GCSE, you will typically be given a small list and asked to trace a linear search, recording the comparisons made at each step.

对于一个包含 n 个元素的列表，最坏情况是目标元素在末尾或根本不存在，此时需要 n 次比较。因此，线性搜索的时间复杂度为 O(n)。虽然它实现简单，但对于非常大的列表效率低下。在 GCSE 中，通常会给你一个小列表并要求你追踪线性搜索，记录每一步的比较情况。

4. Binary Search | 二分搜索

Binary search is a much more efficient algorithm, but it requires the list to be sorted beforehand. It works by repeatedly dividing the search interval in half. The algorithm compares the target value with the middle element of the list. If they are equal, the search is successful. If the target is smaller, the search continues on the lower half; if larger, on the upper half. This process repeats until the target is found or the sub-list has no elements.

二分搜索是一种效率高得多的算法，但它要求列表预先排好序。其原理是不断将搜索区间分成两半。算法将目标值与列表中间元素比较。如果相等，搜索成功。如果目标值更小，则在下半区继续搜索；如果更大，则在上半区继续。这一过程反复进行，直到找到目标或子列表没有元素为止。

Because the list size halves each time, the maximum number of comparisons is about log₂ n, giving a time complexity of O(log n). For a list of 1000 items, binary search needs at most about 10 comparisons, whereas linear search could need up to 1000. In exam questions, you might be asked to demonstrate a binary search on a sorted list, showing the middle index, the comparison result, and the new search boundaries at each stage.

由于每次都将列表大小减半，最多比较次数约为 log₂ n，时间复杂度为 O(log n)。对于一个有 1000 个元素的列表，二分搜索最多需要约 10 次比较，而线性搜索可能需要 1000 次。在考试题目中，你可能会被要求对一个已排序的列表演示二分搜索，展示每一步的中间索引、比较结果以及新的搜索边界。

5. Bubble Sort | 冒泡排序

Bubble sort is one of the simplest sorting algorithms, often used to introduce the concept of iterative comparison and swapping. It repeatedly steps through a list, compares adjacent elements, and swaps them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, indicating that the list is sorted. A standard optimisation is to note that after each complete pass, the largest unsorted element “bubbles up” to its correct position at the end, so the next pass can ignore the already sorted portion.

冒泡排序是最简单的排序算法之一，常用来引入迭代比较和交换的概念。它反复遍历列表，比较相邻元素，如果顺序错误就交换它们。遍历列表的操作会不断重复，直到不需要任何交换为止，这表明列表已经有序。一种标准的优化是注意到每完成一次完整遍历，最大的未排序元素就会“冒泡”到其正确的末尾位置，因此下一次遍历可以忽略已经有序的部分。

In pseudocode, a bubble sort for a list of n items uses a loop inside another loop. The outer loop controls the number of passes, and the inner loop performs the comparisons and swaps. For a list [5, 3, 8, 1], the first pass compares (5,3) → swap, (5,8) → no swap, (8,1) → swap, yielding [3, 5, 1, 8]. The second pass compares (3,5) → no swap, (5,1) → swap, giving [3, 1, 5, 8]. The third pass swaps (3,1) to get [1, 3, 5, 8]. A final pass completes with no swaps, so the algorithm stops.

在伪代码中，对一个包含 n 个元素的列表进行冒泡排序会使用一个循环嵌套在另一个循环内。外层循环控制遍历的轮数，内层循环执行比较和交换。对于列表 [5, 3, 8, 1]，第一轮遍历比较 (5,3)→交换，(5,8)→不交换，(8,1)→交换，得到 [3, 5, 1, 8]。第二轮比较 (3,5)→不交换，(5,1)→交换，得到 [3, 1, 5, 8]。第三轮交换 (3,1)→交换，得到 [1, 3, 5, 8]。最后一轮遍历没有发生交换，算法停止。

Bubble sort has an average and worst-case time complexity of O(n²), making it impractical for large data sets, but it is a common exam topic due to its straightforward logic.

冒泡排序的平均和最坏情况时间复杂度为 O(n²)，这使得它不适合大型数据集，但由于逻辑简单明了，它是常见的考试主题。

6. Merge Sort | 归并排序

Merge sort is a divide-and-conquer algorithm that recursively splits a list into smaller sub-lists, sorts them, and then merges them back together to produce a sorted list. It is a more efficient sorting method, with a time complexity of O(n log n) in all cases. The process starts by dividing the unsorted list into n sub-lists, each containing one element (a list of one is considered sorted). Then, it repeatedly merges sub-lists to produce new sorted sub-lists until only one remains.

归并排序是一种分治算法，它以递归方式将列表分割成更小的子列表，对其进行排序，然后再将这些子列表归并在一起，产生一个有序列表。这是一种更高效的排序方法，在所有情况下的时间复杂度均为 O(n log n)。过程始于将未排序列表分割成 n 个子列表，每个子列表包含一个元素（只有一个元素的列表视为已排序）。然后，反复归并子列表以生成新的有序子列表，直到只剩下一个列表。

The merge step itself is the core operation: take two sorted sub-lists and repeatedly compare the smallest unmerged elements, placing the smaller one into the output list. For example, to merge [2, 5] and [3, 4], compare 2 and 3 → output 2, then compare 5 and 3 → output 3, then 5 and 4 → output 4, and finally 5. The result is [2, 3, 4, 5]. In the exam, you may be asked to perform the merge steps on a given list, showing the splitting and merging stages.

归并步骤本身是核心操作：取两个已排序的子列表，反复比较各自最小的未归并元素，将较小的那个放入输出列表。例如，要归并 [2, 5] 和 [3, 4]，比较 2 和 3 →输出 2，然后比较 5 和 3 →输出 3，再比较 5 和 4 →输出 4，最后输出 5。结果为 [2, 3, 4, 5]。在考试中，你可能会被要求对给定列表执行归并步骤，展示分割和归并的各个阶段。

7. Comparing Sorting and Searching Algorithms | 排序与搜索算法的比较

When choosing an algorithm, efficiency and suitability for the data are crucial. The table below summarises the key features of the four main algorithms covered at GCSE.

当选择算法时，效率和对数据的适用性至关重要。下表总结了 GCSE 涵盖的四种主要算法的关键特征。

Algorithm \| 算法	Best Time \| 最好情况	Worst Time \| 最坏情况	Requires Sorted Data? \| 需要有序数据？
Linear Search \| 线性搜索	O(1)	O(n)	No \| 否
Binary Search \| 二分搜索	O(1)	O(log n)	Yes \| 是
Bubble Sort \| 冒泡排序	O(n)	O(n²)	No \| 否
Merge Sort \| 归并排序	O(n log n)	O(n log n)	No \| 否

Bubble sort is easy to understand but slow for large lists. Merge sort is faster but uses more memory and is conceptually more complex. Linear search is flexible as it works on any list, whereas binary search is dramatically faster on sorted data. Understanding these trade-offs helps you justify choices, a skill that exam questions often test.

冒泡排序易于理解，但对于大型列表速度很慢。归并排序速度更快，但占用更多内存，且概念上更复杂。线性搜索灵活，因为它可用于任何列表，而二分搜索在有序数据上速度要快得多。理解这些权衡有助于你做出合理选择，这也是考题经常考查的一项技能。

8. Algorithm Efficiency and Complexity | 算法效率与复杂度

The efficiency of an algorithm describes how its run time or memory usage grows as the input size increases. In GCSE, we focus on time complexity using Big O notation. O(1) means constant time, O(n) linear, O(log n) logarithmic, O(n²) quadratic, and O(n log n) linearithmic. The notation ignores constant factors and lower-order terms, describing only the dominant trend.

算法的效率描述了随着输入规模增大，其运行时间或内存占用如何增长。在 GCSE 中，我们主要关注用大 O 记号表示的时间复杂度。O(1) 表示常数时间，O(n) 线性，O(log n) 对数，O(n²) 平方，O(n log n) 线性对数。该记号忽略常数因子和低阶项，只描述主导趋势。

For instance, bubble sort’s nested loops give n × (n-1)/2 comparisons, which simplifies to O(n²). Merge sort’s divide-and-conquer approach gives a recurrence relation leading to O(n log n). Binary search halves the problem size each time, producing O(log n). Being able to identify simple nested loops as O(n²) or a single loop through a list as O(n) is a valuable exam skill. You may also be asked to compare algorithms based on the number of operations rather than formal Big O.

例如，冒泡排序的嵌套循环产生 n×(n-1)/2 次比较，简化为 O(n²)。归并排序的分治方法产生递推关系，推导出 O(n log n)。二分搜索每次将问题规模减半，得到 O(log n)。能够识别出简单的嵌套循环为 O(n²)、遍历列表的单层循环为 O(n)，是宝贵的考试技能。你可能还会被要求基于操作次数而不是正式的大 O 记号来比较算法。

9. Tracing Algorithms | 追踪算法

Tracing means manually stepping through an algorithm with a given input and recording the values of variables at each step. This is a heavily tested skill. You will often be presented with a flowchart or pseudocode and asked to complete a trace table. A trace table has columns for each variable (and sometimes outputs) and rows for each step or iteration. You should update variable values exactly as the instructions dictate, paying close attention to the order of operations and loop conditions.

追踪是指使用给定输入手动逐步执行算法，并记录每一步的变量值。这是一项经常被考查的技能。你常常会看到一张流程图或一段伪代码，并被要求完成追踪表格。追踪表格的列对应每个变量（有时也包括输出），行对应每一步或每一次迭代。你应严格按照指令更新变量值，并密切注意操作的顺序和循环条件。

Consider a simple while loop that counts from 1 to 5. The trace table would show the loop counter starting at 1, incrementing until it becomes 6, at which point the condition fails and the loop exits. When tracing a binary search, you would track the low, high, and mid indices, along with the comparison outcomes. Tracing helps reveal logical errors, such as off-by-one mistakes or incorrect loop termination conditions. Always double-check the values after each iteration; one small mistake can cascade through the rest of the trace.

考虑一个从 1 数到 5 的简单 while 循环。追踪表格会显示循环计数器从 1 开始，递增直到变为 6，此时条件不成立，循环退出。在追踪二分搜索时，你会追踪 low、high 和 mid 索引，以及比较结果。追踪有助于揭示逻辑错误，例如差一错误或错误的循环终止条件。每次迭代后都要仔细检查变量值；一个小错误可能会波及追踪的其余部分。

10. Correcting Errors in Algorithms | 纠正算法中的错误

Examination questions may present an algorithm with a deliberate flaw and ask you to identify and correct it. Common errors include incorrect loop conditions (e.g., using < instead of ≤), missing initialisations, swapped assignments, or infinite loops. For example, a binary search that updates the low and high boundaries incorrectly could skip the target element or loop forever. A bubble sort that omits the flag to detect swaps may perform unnecessary passes.

考试题目可能会给出一个带有故意缺陷的算法，要求你识别并纠正它。常见的错误包括错误的循环条件（例如，用了 < 而不是 ≤）、缺少初始化、赋值颠倒，或者无限循环。例如，二分搜索如果错误地更新 low 和 high 边界，可能会跳过目标元素或永远循环。冒泡排序如果省略了检测交换的标志，可能会执行不必要的遍历。

To spot these errors, work through the algorithm with a small test case. If the output is wrong, backtrack to find the step where the logic deviates. Check boundary conditions carefully: does the algorithm work for the first and last elements? Does it handle an empty list? Once the bug is found, suggest a precise fix, such as changing a symbol or adding a missing line. The ability to debug algorithms demonstrates deep understanding and is highly rewarded.

要发现这些错误，可以用一个小测试用例逐步执行算法。如果输出错误，就回溯找出逻辑出错的步骤。仔细检查边界条件：算法对第一个和最后一个元素是否有效？它能否处理空列表？一旦找到漏洞，就提出精确的修正方案，例如修改一个符号或添加缺失的一行。调试算法的能力体现了深刻的理解，在考试中会得到高度认可。

11. Worked Examples and Practice Approaches | 实例解析与练习方法

Let’s apply these ideas to a typical exam-style problem. Suppose we have the sorted list [2, 5, 8, 12, 16, 23, 38, 45] and are performing a binary search for the value 23. The initial low = 1, high = 8, mid = 4 (value 12). Since 23 > 12, discard left half: low becomes 5, high remains 8. New mid = 6 (value 23). Match found after 2 comparisons. The trace table would show indices and decisions at each step. Practising such traces helps you gain speed and accuracy.

让我们将这些思路应用到一个典型的考试式题目中。假设有已排序列表 [2, 5, 8, 12, 16, 23, 38, 45]，要对值 23 执行二分搜索。初始 low=1，high=8，mid=4（值为 12）。由于 23 > 12，舍弃左半部分：low 变为 5，high 仍为 8。新的 mid=6（值为 23）。经过 2 次比较找到匹配。追踪表格会显示每一步的索引和判定。练习这类追踪有助于你提高速度和准确性。

For sorting, try taking a small unsorted list like [7, 2, 5, 1] and performing a bubble sort and a merge sort side by side. Notice how many comparisons each one makes. This active comparison builds intuition about efficiency. When revising, do not just read about algorithms; write out the steps by hand or draw flowcharts to cement the logical flow. The more you practise, the easier it becomes to handle unseen algorithm questions under timed conditions.

对于排序，尝试取一个小的未排序列表，如 [7, 2, 5, 1]，并同时执行冒泡排序和归并排序。注意它们各自进行多少次比较。这种主动的比较能培养对效率的直觉。复习时，不要只阅读算法描述；要手写出步骤或画出流程图，以巩固逻辑流程。练习得越多，在计时条件下处理陌生的算法题目就越轻松。

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

Always read the question carefully to determine whether the list is sorted, as this affects which search algorithm can be used. If a binary search is required but the list is unsorted, you must first mention sorting; otherwise, the answer is invalid. When completing trace tables, be systematic: fill in each cell only when the value changes, and keep track of the step number. Many candidates lose marks by missing an update or writing values in the wrong row.

务必仔细审题以确定列表是否已排序，因为这决定了可以使用哪种搜索算法。如果要求使用二分搜索但列表未排序，你必须先提到排序；否则答案无效。在完成追踪表格时，要有条不紊：仅在变量值发生变化时才填入对应单元格，并记录步骤编号。很多考生因为遗漏一次更新或将数值写在了错误的行而丢分。

Another common pitfall is confusing the merge step in merge sort with other operations. Remember that merging always combines two already sorted lists by repeatedly taking the smaller front element. In bubble sort, ensure you understand the optimisation that reduces the number of comparisons each pass; often the question expects you to stop early if no swaps occur. For efficiency questions, avoid vague terms like “faster” – instead, refer to the number of comparisons or the order of growth using Big O.

另一个常见误区是将归并排序中的归并步骤与其他操作混淆。要记住，归并总是通过反复取出前端的较小元素来合并两个已经有序的列表。在冒泡排序中，要确保你理解那个能减少每轮比较次数的优化措施；题目常常期望你在没有发生交换时提前停止。对于效率类问题，避免使用“更快”这样模糊的词语——取而代之的是提及比较次数或使用大 O 记号表示的增长量级。

Finally, manage your time: tracing questions can be lengthy but are usually worth several marks. Write neatly and double-check loop termination conditions before moving on. If you get stuck, move to the next part and return later. Algorithms are a test of logical rigour, and with methodical preparation, they can become some of the most reliable marks on the paper.

最后，要管理好时间：追踪题可能篇幅较长，但通常分值可观。书写要整洁，在继续下一步之前再次检查循环终止条件。如果卡住了，就跳到下一部分，稍后再回来。算法是对逻辑严谨性的考验，通过有条理的准备，它们可以成为试卷上最有把握的得分点之一。

Published by TutorHao | GCSE AQA Mathematics Revision Series | aleveler.com

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

Mastering Algorithms for GCSE AQA Mathematics | GCSE AQA 数学：算法 考点精讲