A-Level CCEA Computer Science: Algorithms Revision Guide | CCEA A-Level 计算机：算法考点精讲

📚 A-Level CCEA Computer Science: Algorithms Revision Guide | CCEA A-Level 计算机：算法考点精讲

Algorithms are the heart of computer science. For CCEA A-Level candidates, mastering the core concepts of algorithms – from basic definitions to efficiency analysis – is essential to succeed in both AS and A2 units. This guide breaks down every key topic in the syllabus, offering clear explanations, practical examples, and bilingual notes to help you revise effectively.

算法是计算机科学的核心。对于CCEA A-Level考生来说，掌握算法的核心概念——从基本定义到效率分析——是在AS和A2单元中取得好成绩的关键。本指南分解了大纲中的每个重要主题，提供清晰的解释、实用示例和中英双语注释，助你高效备考。

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

An algorithm is a finite sequence of well-defined, unambiguous steps designed to solve a specific problem or accomplish a task. Every algorithm must have an input, produce an output, and terminate after a finite number of steps.

算法是用于解决特定问题或完成特定任务的一组有限、定义清晰且无歧义的步骤序列。每个算法必须有输入、产生输出，并在有限步骤后终止。

Algorithms are independent of any programming language. The same algorithm can be implemented in Python, Java, or pseudocode. The CCEA specification requires you to understand and trace algorithms written in pseudocode as well as flowcharts.

算法独立于任何编程语言。同一个算法可以用Python、Java或伪代码来实现。CCEA大纲要求你能够理解并追踪以伪代码和流程图编写的算法。

Key properties that define an algorithm include: definiteness (each step is precisely stated), effectiveness (each step can be carried out in finite time), and generality (it works for a class of inputs, not just one case).

定义算法的关键属性包括：确定性（每个步骤都精确描述）、可行性（每个步骤都能在有限时间内执行）和通用性（算法适用于一类输入，而非仅针对单个情况）。

2. Representing Algorithms | 算法的表示方法

CCEA expects you to be comfortable with two main forms of algorithm representation: pseudocode and flowcharts. Both serve to communicate the logic of an algorithm before coding begins.

CCEA希望你熟练掌握两种主要的算法表示形式：伪代码和流程图。两者都用于在编程之前传达算法的逻辑。

Pseudocode uses structured English-like statements, avoiding strict syntax rules. Common constructs include IF...THEN...ELSE...ENDIF, WHILE...DO...ENDWHILE, and FOR...NEXT. Variables are assigned using the ← symbol.

伪代码使用结构化的类英语语句，避免严格的语法规则。常见结构包括 IF...THEN...ELSE...ENDIF、WHILE...DO...ENDWHILE 和 FOR...NEXT。变量赋值使用 ← 符号。

Sequence: steps performed one after another.
Selection: branching based on a condition (IF statements).
Iteration: repeating a block of code (WHILE, FOR, REPEAT…UNTIL).

顺序： 逐步执行的步骤。
选择： 基于条件的分支（IF语句）。
迭代： 重复执行一段代码（WHILE、FOR、REPEAT…UNTIL）。

Flowcharts use standard symbols: ovals for start/end, parallelograms for input/output, rectangles for processes, and diamonds for decisions. Arrows indicate the flow of control. You must be able to interpret and draw simple flowcharts for given problems.

流程图使用标准符号：椭圆形表示开始/结束，平行四边形表示输入/输出，矩形表示处理过程，菱形表示判断。箭头指示控制流的走向。你必须能够解释并绘制用于给定问题的简单流程图。

3. Standard Algorithms: Searching | 标准算法：查找

Searching algorithms retrieve information stored in data structures. The two fundamental searches you must know are linear search and binary search.

查找算法检索存储在数据结构中的信息。你必须掌握的两种基本查找方法是线性查找和二分查找。

Linear search works on any list, sorted or unsorted. It checks each element sequentially until the target is found or the list ends. Its time complexity is O(n) in the worst case.

线性查找适用于任何列表，无论是否已排序。它按顺序检查每个元素，直到找到目标或列表结束。最坏情况下时间复杂度为 O(n)。

Pseudocode for linear search:

线性查找的伪代码：

FUNCTION linearSearch(arr, target)
  FOR i ← 0 TO LEN(arr)-1
    IF arr[i] = target THEN RETURN i
  ENDFOR
  RETURN -1
END FUNCTION

Binary search requires the array to be sorted. It repeatedly divides the search interval in half, comparing the target with the middle element. Time complexity is O(log n).

二分查找要求数组已排序。它反复将搜索区间一分为二，将目标与中间元素比较。时间复杂度为 O(log n)。

Binary search logic:

二分查找逻辑：

FUNCTION binarySearch(arr, target)
  low ← 0
  high ← LEN(arr) – 1
  WHILE low ≤ high DO
    mid ← FLOOR((low + high) / 2)
    IF arr[mid] = target THEN RETURN mid
    ELSE IF arr[mid] < target THEN low ← mid + 1
    ELSE high ← mid – 1
  ENDWHILE
  RETURN -1
END FUNCTION

Understanding when to apply each search is crucial for efficiency-related exam questions.

理解何时应用每种查找方法对于效率相关的考题至关重要。

4. Standard Algorithms: Sorting | 标准算法：排序

Sorting algorithms rearrange data into a particular order (ascending or descending). The CCEA specification highlights bubble sort, insertion sort, and merge sort as key examples.

排序算法将数据重新排列成特定顺序（升序或降序）。CCEA大纲重点强调了冒泡排序、插入排序和归并排序。

Bubble sort repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The pass is repeated until no swaps are needed. Worst case and average O(n²).

冒泡排序反复遍历列表，比较相邻元素，如果顺序错误则交换。重复多遍直到无需再交换。最坏和平均时间复杂度为 O(n²)。

Insertion sort builds the sorted array one element at a time, inserting each new element into its correct position among previously sorted items. It is efficient for small or nearly sorted data sets, also O(n²) worst case.

插入排序逐个构建已排序序列，将每个新元素插入到之前已排序部分的正确位置。对于小型或近似有序的数据集效率较高，最坏情况也为 O(n²)。

Merge sort is a divide-and-conquer algorithm. It splits the list into halves, recursively sorts each half, then merges the sorted halves back together. Its time complexity is O(n log n) in all cases, making it efficient for large data sets.

归并排序是一种分治算法。它将列表分成两半，递归地对每一半排序，然后将排好序的两半合并。所有情况下时间复杂度均为 O(n log n)，对于大数据集十分高效。

You should be able to trace these algorithms, recognise their pseudocode, and compare their performance characteristics.

你应当能够追踪这些算法、识别其伪代码，并比较它们的性能特征。

5. Algorithm Efficiency and Big O Notation | 算法效率与大O表示法

Big O notation describes the upper bound of an algorithm’s time or space complexity as the input size n grows. It helps compare algorithms without depending on hardware implementation.

大O表示法描述的是随着输入规模 n 增大，算法时间复杂度或空间复杂度的上界。它有助于在不依赖硬件实现的情况下比较算法。

Common complexities in increasing order of growth:

按增长率递增顺序排列的常见复杂度：

Notation / 表示法	Name / 名称	Example / 示例
O(1)	Constant / 常数	Array access by index
O(log n)	Logarithmic / 对数	Binary search
O(n)	Linear / 线性	Linear search
O(n log n)	Linearithmic / 线性对数	Merge sort
O(n²)	Quadratic / 平方	Bubble sort, insertion sort
O(2ⁿ)	Exponential / 指数	Recursive Fibonacci

In the exam, you may be asked to determine the Big O of a given algorithm by analysing the number of basic operations relative to the input size.

考试中，你可能会被要求通过分析基本操作相对于输入规模的次数来确定给定算法的大O。

Space complexity is also important: how much extra memory an algorithm needs. For example, merge sort requires O(n) auxiliary space, while bubble sort operates in-place with O(1) extra space.

空间复杂度同样重要：指的是算法需要多少额外内存。例如，归并排序需要 O(n) 的辅助空间，而冒泡排序就地操作，额外空间为 O(1)。

6. Recursion | 递归

Recursion occurs when a function calls itself in order to solve a smaller instance of the same problem. A recursive algorithm must have a base case to stop the recursion and avoid infinite loops.

当一个函数调用自身来解决同一问题的更小实例时，就发生了递归。递归算法必须有一个基线条件以停止递归，避免无限循环。

A classic example is computing the factorial of n:

一个经典的例子是计算 n 的阶乘：

FUNCTION factorial(n)
IF n = 0 THEN RETURN 1
ELSE RETURN n × factorial(n-1)
END FUNCTION

Recursion can simplify code for problems with self-similar structure, like tree traversal, but it often carries extra overhead and risk of stack overflow if not carefully designed. CCEA candidates should be able to trace recursive calls and understand the concept of the call stack.

递归可以简化具有自相似结构问题的代码，如树的遍历，但如果设计不当，通常会带来额外的开销和栈溢出风险。CCEA考生应能追踪递归调用，并理解调用栈的概念。

7. Common Algorithmic Techniques | 常见算法技巧

The CCEA syllabus introduces several problem-solving paradigms. Understanding these helps you design and evaluate algorithms.

CCEA大纲介绍了几种问题解决的范式。理解这些有助于你设计和评估算法。

Divide and conquer breaks a problem into smaller sub-problems, solves them independently, and combines results. Merge sort and binary search are prime examples.

分治法将问题分解为更小的子问题，独立求解，再合并结果。归并排序和二分查找是主要范例。

Greedy algorithms make the locally optimal choice at each step, hoping to find a global optimum. They do not always guarantee the best solution but are efficient for certain problems like the fractional knapsack problem.

贪心算法在每一步做出局部最优选择，希望找到全局最优解。它们并不总能保证最佳解，但对于如分数背包问题等特定问题很高效。

Backtracking systematically explores all potential solutions by building candidates incrementally and abandoning a candidate (backtracking) as soon as it is determined to be invalid. It is used in puzzles, maze solving, and the N-Queens problem.

回溯法系统地探索所有可能的解，通过逐步构建候选解，并在确定某候选解无效时立即舍弃（回溯）。它用于谜题、迷宫求解和 N 皇后问题。

Recognising which technique suits a given problem is a higher-order skill that examiners look for in extended questions.

识别哪种技巧适合给定的问题是一种高阶技能，也是考官在拓展题中期望看到的。

8. Tracing Algorithms | 算法追踪与调试

Tracing an algorithm involves mentally executing it step-by-step with sample data, recording the values of variables at each stage. This is heavily tested in CCEA papers, often in pseudocode or flowchart form.

算法追踪是指用样本数据在脑海中逐步执行算法，记录每一步变量的值。这在CCEA试卷中经常出现，通常以伪代码或流程图形式考查。

Effective tracing requires a systematic approach: use a trace table with columns for variables and conditions. Update the table after each step, noting any output produced.

有效的追踪需要系统的方法：使用追踪表，以变量和条件为列。每步后更新表格，记录产生的任何输出。

Common pitfalls include misunderstanding loop bounds (e.g. whether a FOR loop is inclusive or exclusive of the end value), misinterpreting assignment versus comparison, and neglecting to reset variables in nested loops.

常见陷阱包括：误解循环边界（例如 FOR 循环是否包含结束值）、混淆赋值与比较，以及在嵌套循环中忘记重置变量。

Practice tracing algorithms with both iterative and recursive structures, as this skill directly transfers to writing and debugging your own code.

练习追踪迭代和递归结构的算法，因为这一技能可直接迁移到你编写和调试自己的代码上。

9. Space and Time Trade-offs | 时空权衡

Often, you can improve an algorithm’s speed at the cost of using more memory, or reduce memory usage by accepting more computation time. This is the space–time trade-off.

通常，你可以通过使用更多内存来提高算法速度，或通过接受更多计算时间来减少内存使用。这就是时空权衡。

For example, using a hash table (lookup table) provides O(1) average search time but consumes extra memory to store the table. In contrast, linear search uses minimal space but is O(n) in time.

例如，使用哈希表（查找表）可提供平均 O(1) 的查找时间，但需要额外内存存储该表。相反，线性查找使用的空间极少，但时间为 O(n)。

Merge sort requires O(n) extra space, whereas quicksort (if implemented with in-place partitioning) uses O(log n) space on average, though its worst case is O(n). Understanding these differences helps you justify algorithm choices in exam scenarios.

归并排序需要 O(n) 的额外空间，而快速排序（如果实现为就地分区）平均使用 O(log n) 空间，尽管最坏情况为 O(n)。理解这些差异有助于你在考试情境中论证算法的选择。

10. Exam Tips for Algorithm Questions | 算法题考试技巧

When tackling CCEA A-Level algorithm questions, always read the problem statement carefully and identify what the algorithm is supposed to achieve. Pay attention to details such as initial values, loop termination conditions, and data types.

在解答CCEA A-Level算法题时，一定要仔细阅读问题陈述，明确算法的目标。注意初始值、循环终止条件和数据类型等细节。

If asked to complete a trace table, work systematically – do not skip steps. Show all intermediate values; marks are often awarded for partial correctness even if the final result is wrong.

如果要求完成追踪表，要系统地进行——不要跳过步骤。展示所有中间值；即使最终结果错误，部分正确性通常也能得分。

For algorithm design questions, use clear, structured pseudocode. Commenting your logic in plain English can help the examiner follow your thinking, but keep it concise. Always consider edge cases (empty input, single-element input, extreme values).

对于算法设计题，使用清晰、结构化的伪代码。用简单英语注释你的逻辑可以帮助考官理解你的思路，但要简洁。始终考虑边缘情况（空输入、单元素输入、极值）。

Finally, revise the specific algorithms listed in the specification: linear search, binary search, bubble sort, insertion sort, merge sort. Know their complexities and be able to write them from memory.

最后，复习大纲中列出的具体算法：线性查找、二分查找、冒泡排序、插入排序、归并排序。了解它们的复杂度，并能默写出来。

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

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

A-Level CCEA Computer Science: Algorithms Revision Guide | CCEA A-Level 计算机：算法考点精讲