A-Level WJEC Computer Science: Algorithm Essentials | A-Level WJEC 计算机：算法核心考点精讲

📚 A-Level WJEC Computer Science: Algorithm Essentials | A-Level WJEC 计算机：算法核心考点精讲

Mastering algorithms is the cornerstone of success in the WJEC A-Level Computer Science specification. This guide unpacks every critical aspect of the topic, from pseudocode conventions and classic search/sort techniques to Big O analysis and recursion. You will gain the clarity needed to write efficient, exam-ready solutions and confidently tackle Paper 2 questions.

掌握算法是 WJEC A-Level 计算机科学考试成功的基石。本指南剖析了该主题的每一个关键方面，从伪代码约定和经典搜索/排序技术到 Big O 分析与递归。你将获得所需的清晰理解，以编写高效、符合考试要求的解决方案，并自信地应对 Paper 2 的题目。

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

An algorithm is a step-by-step procedure or set of rules designed to perform a specific task or solve a particular problem. In computer science, algorithms must be unambiguous, finite, and effective—each step needs to be precisely defined, the process must eventually terminate, and every operation must be feasible under the given constraints. WJEC examiners expect you to recognise these properties and apply them when evaluating or designing solutions.

算法是为执行特定任务或解决特定问题而设计的分步程序或规则集。在计算机科学中，算法必须无二义性、有穷且有效——每一步都需要精确定义，过程必须最终终止，并且每个操作在给定约束下都必须是可行的。WJEC 考官希望你能够识别这些特性，并在评估或设计解决方案时加以应用。

2. Representing Algorithms | 算法表示

Algorithms can be communicated using structured English, flowcharts, or pseudocode. For WJEC, the primary method you will use in exams is pseudocode, which closely mirrors the official reference syntax. Flowcharts are occasionally tested for their ability to visualise decision points and loops, so you should be comfortable converting between these representations. Regardless of format, clarity and logical flow remain paramount.

算法可以使用结构化英语、流程图或伪代码来传达。在 WJEC 考试中，你将使用的主要方法是伪代码，它严格遵循官方参考语法。流程图偶尔会考察，用以展示其可视化决策点和循环的能力，因此你应能熟练地在这些表示法之间进行转换。无论采用何种格式，清晰度和逻辑流程仍然至关重要。

3. Pseudocode Syntax in WJEC | WJEC 伪代码语法

WJEC pseudocode uses a Pascal-like structure. Key constructs include DECLARE for variables, INPUT and OUTPUT for IO, IF ... THEN ... ELSE ... ENDIF for selection, and WHILE ... DO ... ENDWHILE or FOR ... TO ... NEXT for iteration. Arrays are declared with upper bound and type, e.g., DECLARE scores : ARRAY[1:10] OF INTEGER. Assignments use the ← symbol, and equality is tested with =. Make sure you consistently follow this syntax: missing ENDIF or incorrectly typed operators lose marks.

WJEC 伪代码采用类似 Pascal 的结构。关键结构包括：用 DECLARE 声明变量，用 INPUT 和 OUTPUT 进行输入输出，用 IF ... THEN ... ELSE ... ENDIF 实现选择，用 WHILE ... DO ... ENDWHILE 或 FOR ... TO ... NEXT 进行迭代。数组声明需指明上界和类型，例如 DECLARE scores : ARRAY[1:10] OF INTEGER。赋值使用 ← 符号，相等性测试使用 =。请确保始终遵循此语法：遗漏 ENDIF 或运算符类型错误都会丢分。

4. Searching Algorithms | 搜索算法

Linear Search checks each element sequentially from the start until the target is found or the end is reached. It works on unsorted data and has O(n) worst-case time complexity. In pseudocode, you would iterate through the array with a FOR loop, comparing each item to the search key.

线性搜索从开头依次检查每个元素，直到找到目标或到达末尾。它适用于未排序的数据，最坏情况时间复杂度为 O(n)。在伪代码中，你将使用 FOR 循环遍历数组，将每一项与搜索键进行比较。

Binary Search requires a sorted array. It repeatedly divides the search interval in half, comparing the middle element with the target. If the target is smaller, the search continues in the lower half; if larger, in the upper half. Each step halves the problem size, leading to O(log n) complexity. Pseudo must show initialisation of low, high, and a WHILE loop that updates mid.

二分搜索要求数组已排序。它反复将搜索区间分成两半，将中间元素与目标进行比较。如果目标较小，则在较低的那一半继续搜索；如果较大，则在较高的那一半继续搜索。每一步将问题规模减半，复杂度为 O(log n)。伪代码必须展示 low、high 的初始化，以及更新 mid 的 WHILE 循环。

5. Sorting Algorithms | 排序算法

WJEC requires understanding of three core sorts: Bubble Sort, Insertion Sort, and Merge Sort. You must be able to trace them on sample data and write correct pseudocode. All three illustrate different efficiency classes and algorithmic thinking patterns.

WJEC 要求理解三种核心排序：冒泡排序、插入排序和归并排序。你必须能够对示例数据进行跟踪，并编写正确的伪代码。这三种排序展示了不同的效率类别和算法思维模式。

Bubble Sort progressively moves larger elements to the end by repeatedly swapping adjacent out-of-order pairs. After each pass, the largest unsorted element “bubbles” to its correct position. An optimised version uses a swapped flag to stop early if no swaps occur. Its average and worst complexity is O(n²).

冒泡排序通过反复交换相邻的乱序对，逐步将较大的元素移动到末尾。每趟扫描后，最大的未排序元素会“冒泡”到正确位置。优化版本使用 swapped 标志，若未发生交换则提前终止。平均和最坏复杂度均为 O(n²)。

Insertion Sort builds the sorted list one element at a time, taking each new element and inserting it into its correct place within the already sorted portion. It is efficient for small or partially sorted datasets and has O(n²) worst case but O(n) best case (when nearly sorted).

插入排序一次一个元素地构建有序列表，取出每个新元素并将其插入已排序部分的正确位置。对于小型或部分已排序的数据集，它效率较高，最坏情况 O(n²)，最好情况 O(n)（当数据接近有序时）。

Merge Sort uses a divide-and-conquer strategy: it recursively splits the array into halves until single elements remain, then merges those halves back together in sorted order. Merging requires a temporary array. Its guaranteed O(n log n) performance makes it superior for large datasets, at the cost of extra space.

归并排序采用分治策略：它递归地将数组分成两半，直到剩下单个元素，然后将这些半部分按排序顺序合并回来。合并时需要临时数组。其保证的 O(n log n) 性能使其在处理大数据集时更优越，代价是需要额外空间。

6. Comparing Sorting Algorithms | 排序算法对比

Algorithm 算法	Best 最好	Average 平均	Worst 最坏	Stable? 稳定？	In-place? 原地？
Bubble Sort	O(n)	O(n²)	O(n²)	Yes	Yes
Insertion Sort	O(n)	O(n²)	O(n²)	Yes	Yes
Merge Sort	O(n log n)	O(n log n)	O(n log n)	Yes	No

For WJEC, memorising these complexities is essential. Stability (preserving the original order of equal elements) matters when sorting secondary keys. In-place algorithms use constant extra memory, while Merge Sort requires O(n) additional space, which can be a deciding factor in memory-constrained environments.

对于 WJEC，熟记这些复杂度至关重要。当对次要关键字排序时，稳定性（保留相等元素的原始顺序）很重要。原地算法仅使用常量级额外内存，而归并排序需要 O(n) 额外空间，这在内存受限环境中可能成为决定因素。

7. Time Complexity & Big O Notation | 时间复杂度与 Big O 表示法

Big O notation describes the upper bound of an algorithm’s running time as the input size n grows. It ignores constants and lower-order terms, focusing on the dominating term. The most common complexities you will meet are O(1) (constant), O(log n) (logarithmic), O(n) (linear), O(n log n) (linearithmic), O(n²) (quadratic), and O(2ⁿ) (exponential). Always relate these to actual code structures: a single loop usually gives O(n), nested loops often give O(n²), and halving the input each iteration suggests O(log n).

Big O 表示法描述了随着输入规模 n 的增长，算法运行时间的上限。它忽略常数和低阶项，专注于占主导地位的项。你将遇到的最常见复杂度包括：O(1)（常数），O(log n)（对数），O(n)（线性），O(n log n)（线性对数），O(n²)（平方），和 O(2ⁿ)（指数）。务必将这些与实际的代码结构联系起来：单个循环通常给出 O(n)，嵌套循环通常给出 O(n²)，每次迭代将输入减半则暗示 O(log n)。

A typical WJEC question might ask: “Calculate the time complexity of the following pseudocode.” You need to count nested loops and recognise how the number of iterations grows with n. For example, a loop that runs n times containing an inner loop that also runs n times yields n × n = O(n²).

典型的 WJEC 题目可能会问：“计算以下伪代码的时间复杂度。”你需要统计嵌套循环，并识别迭代次数如何随 n 增长。例如，一个运行 n 次的循环内部包含一个同样运行 n 次的循环，则得出 n × n = O(n²)。

8. Space Complexity | 空间复杂度

Space complexity measures the total memory an algorithm needs relative to the input size. While time efficiency often grabs the spotlight, WJEC expects you to consider both. An in-place algorithm like Insertion Sort uses O(1) extra memory—great for limited RAM. Recursive algorithms can cause O(n) stack space if the recursion depth scales with n, such as an unbalanced recursive implementation. Always state space complexity when asked, and distinguish between auxiliary space and total space.

空间复杂度衡量算法所需的总内存与输入规模的关系。虽然时间效率经常引人注目，但 WJEC 期望你两者兼顾。像插入排序这样的原地算法仅使用 O(1) 额外内存——非常适合内存有限的环境。如果递归深度随 n 增长（例如不平衡的递归实现），递归算法可能导致 O(n) 的栈空间。当被问及时，请务必陈述空间复杂度，并区分辅助空间和总空间。

9. Recursion | 递归

Recursion is a technique where a function calls itself to solve smaller instances of the same problem. Every recursive solution must have a base case that stops the recursion and a recursive case that breaks the problem down. Classic examples include factorial computation (base case: n = 0 or 1, return 1), the Fibonacci sequence, and tree traversals. In WJEC pseudocode, recursion is expressed with an IF checking the base case, then a RETURN statement involving the recursive call.

递归是一种函数调用自身来解决同一问题的更小实例的技术。每个递归解决方案都必须有一个停止递归的基准情形，以及一个将问题分解的递归情形。经典例子包括阶乘计算（基准情形：n = 0 或 1，返回 1）、斐波那契数列和树的遍历。在 WJEC 伪代码中，递归通过一个 IF 检查基准情形，然后是一个包含递归调用的 RETURN 语句来表示。

Recursion often provides elegant code but can be inefficient if the same subproblems are recomputed (as in naive Fibonacci). Tail recursion is a special form where the recursive call is the last operation; some compilers can optimise it to iteration, saving stack space. You may be asked to trace a recursive algorithm or compare iterative and recursive solutions.

递归通常能提供优雅的代码，但如果相同的子问题被重复计算（如朴素的斐波那契），则可能效率低下。尾递归是一种特殊形式，其中递归调用是最后一步操作；某些编译器能将其优化为迭代，从而节省栈空间。你可能会被要求跟踪递归算法，或比较迭代与递归解决方案。

10. Algorithm Design Paradigms | 算法设计范式

WJEC introduces students to fundamental design strategies that underpin many algorithms. Divide and Conquer (exemplified by Merge Sort and Binary Search) breaks a problem into independent subproblems, solves them recursively, and combines the results. Greedy algorithms make locally optimal choices at each step, hoping to find a global optimum; they are used in problems like coin change (with certain conditions) and Prim’s/Kruskal’s algorithms. You should recognise the characteristics of each paradigm and be able to suggest a suitable approach for a given problem scenario.

WJEC 向学生介绍了支撑许多算法的基本设计策略。分治法（以归并排序和二分搜索为例）将问题分解为独立的子问题，递归地解决它们，然后合并结果。贪心算法在每一步做出局部最优选择，期望找到全局最优解；它们用于如找零问题（在特定条件下）和普林姆/克鲁斯卡尔算法等问题中。你应该能够识别每种范式的特征，并能为给定的问题场景建议合适的方法。

Other paradigms like dynamic programming (overlapping subproblems, optimal substructure) may appear as extension material, but the core two above are most common in WJEC past papers. Being able to outline the high-level steps of each paradigm—even without full code—can earn you marks in design questions.

其他范式，如动态规划（重叠子问题、最优子结构），可能作为扩展内容出现，但上述两种核心范式在 WJEC 历年试题中最常见。即使是设计问题，能够概括每种范式的高层步骤——即使没有完整代码——也能为你赢得分数。

11. Common Exam Pitfalls | 常见失分点

Missing ENDIF / ENDWHILE in pseudocode: Always close any block structure. WJEC marking schemes penalise syntactically incomplete pseudocode.
混淆赋值与相等：使用 ← 进行赋值，使用 = 进行比较。在条件判断中误用 ← 是常见错误。
Off-by-one errors in loops: Ensure FOR i ← 1 TO n does not become n+1 iterations. Arrays declared with bound 1:10 have exactly 10 elements; indexes start at 1 unless otherwise specified.
循环中的差一错误：确保 FOR i ← 1 TO n 不会变成 n+1 次迭代。声明为 1:10 的数组恰好有 10 个元素；除非另有说明，索引从 1 开始。
Ignoring sorted requirement in Binary Search: The binary search pseudocode must only be applied to a sorted list. If the question does not guarantee sorting, state that a sort is required first, or use linear search.
忽略二分搜索中的有序要求：二分搜索伪代码必须仅应用于已排序列表。如果题目未保证有序，则需说明必须先进行排序，或使用线性搜索。
Not stating assumptions: When analysing complexity, clearly write “assuming the input is of size n” and identify the dominant term.
未说明假设：在分析复杂度时，清楚地写出“假设输入规模为 n”并识别主导项。

12. Summary and Final Tips | 总结与最终建议

Algorithm questions in WJEC A-Level Computer Science reward precision and structured thinking. Internalise the official pseudocode syntax, practice tracing and writing sorts/searches from memory, and always justify your Big O answers with reasoning. Combine algorithmic knowledge with a solid understanding of data structures (arrays, lists, stacks) to excel in both Paper 2 scenarios and the practical programming project. Review past papers repeatedly—pattern recognition in how algorithms are examined is your greatest ally.

WJEC A-Level 计算机科学中的算法题目奖励精确性和结构化思维。内化官方伪代码语法，练习凭记忆跟踪和编写排序/搜索算法，并始终用推理论证你的 Big O 答案。将算法知识与对数据结构（数组、列表、栈）的扎实理解相结合，以便在 Paper 2 情境题和实践编程项目中脱颖而出。反复复习历年真题——对算法考察方式的模式识别是你最大的盟友。

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

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

A-Level WJEC Computer Science: Algorithm Essentials | A-Level WJEC 计算机：算法核心考点精讲