📚 Algorithms: Key Concepts and Exam Focus | 算法：考点精讲
Algorithms are the heart of problem-solving in computer science. An algorithm is a step-by-step sequence of instructions designed to perform a specific task or solve a particular problem. Understanding how algorithms work, how to represent them using pseudocode and flowcharts, and how to evaluate their efficiency is crucial for success in IGCSE Computer Science. This guide covers all the key concepts you need to master, from searching and sorting to trace tables and common pitfalls, with clear explanations in both English and Chinese.
算法是计算机科学解决问题的核心。算法是一组按步骤执行的指令，用于完成特定任务或解决特定问题。理解算法的工作原理、如何用伪代码和流程图表示它们，以及如何评估其效率，对于 IGCSE 计算机科学的成功至关重要。本指南涵盖所有你需要掌握的关键概念，从搜索和排序到跟踪表与常见陷阱，并提供清晰的中英双语解释。
1. What is an Algorithm? | 什么是算法？
An algorithm is a finite sequence of well-defined, unambiguous instructions that can be followed to solve a problem or perform a computation. In computer science, algorithms are independent of any programming language; they describe the logic of a solution before coding begins. Good algorithms are precise, complete, and terminate after a finite number of steps.
算法是一个有限的、明确定义的、无歧义的指令序列，可被遵循以解决问题或执行计算。在计算机科学中，算法独立于任何编程语言；它们在编码开始前描述解决方案的逻辑。好的算法精确、完整，并在有限步数后终止。
Every algorithm must have clearly defined inputs and outputs. For example, a sorting algorithm receives an unsorted list (input) and produces a sorted list (output). The steps must be feasible and arranged in the correct order. Algorithms are not just for computers – a recipe for baking a cake is also an algorithm.
每个算法必须有明确定义的输入和输出。例如，排序算法接收一个无序列表（输入）并产生一个有序列表（输出）。步骤必须可行并按正确顺序排列。算法不仅适用于计算机——烘焙蛋糕的食谱也是一种算法。
2. Representing Algorithms: Pseudocode and Flowcharts | 算法表示：伪代码与流程图
In IGCSE Computer Science, algorithms are often expressed using pseudocode or flowcharts. Pseudocode is a simplified, half-English, half-code language that uses common programming constructs like IF…THEN…ELSE, WHILE loops, and FOR loops. It is not tied to any particular syntax, making it easy to read and write.
在 IGCSE 计算机科学中，算法通常用伪代码或流程图表示。伪代码是一种简化的、半英文半代码的语言，使用常见的编程结构，如 IF…THEN…ELSE、WHILE 循环和 FOR 循环。它不依赖于任何特定语法，因此易于读写。
Flowcharts use symbols to represent different types of actions: ovals for start/end, parallelograms for input/output, rectangles for processes, diamonds for decisions, and arrows to show the flow of control. They provide a visual way to trace the logic of an algorithm.
流程图使用符号表示不同类型的动作：椭圆表示开始/结束，平行四边形表示输入/输出，矩形表示处理过程，菱形表示判断，箭头表示控制流。它们提供了一种可视化的方式来追踪算法的逻辑。
When representing an algorithm, make sure each step is atomic – that is, it cannot be broken down further. Avoid vague statements like ‘sort the list’ unless the sorting method is specified.
在表示算法时，确保每个步骤都是原子的——即不能再进一步分解。避免模糊的语句，如“对列表进行排序”，除非指定了排序方法。
3. Sequence, Selection, and Iteration | 顺序、选择与循环
All algorithms are built from three fundamental control structures: sequence, selection, and iteration. Sequence means executing instructions one after another, in the order they appear. This is the default flow in any algorithm.
所有算法都由三种基本控制结构组成：顺序、选择和循环。顺序意味着按照指令出现的顺序依次执行。这是任何算法中的默认流程。
Selection (or decision) allows the algorithm to choose between two or more paths based on a condition. In pseudocode this is written as IF…THEN…ELSE…ENDIF. A flowchart represents it with a diamond shape containing the condition and branches labeled ‘Yes’ and ‘No’.
选择（或决策）允许算法根据条件在两个或多个路径之间进行选择。在伪代码中写作 IF…THEN…ELSE…ENDIF。流程图用包含条件的菱形表示，分支标记为“是”和“否”。
Iteration means repeating a block of code multiple times. There are two main types: count-controlled loops (FOR…NEXT) and condition-controlled loops (WHILE…ENDWHILE, REPEAT…UNTIL). Iteration is essential for tasks like searching through a list or summing values.
循环意味着重复执行一段代码多次。主要有两种类型：计数控制循环（FOR…NEXT）和条件控制循环（WHILE…ENDWHILE, REPEAT…UNTIL）。循环对于搜索列表或求和等任务至关重要。
4. Linear Search | 线性搜索
Linear search, also known as sequential search, checks each element of a list one by one until the target value is found or the end of the list is reached. It is the simplest searching algorithm and works on both sorted and unsorted lists.
线性搜索，也称顺序搜索，逐个检查列表中的每个元素，直到找到目标值或到达列表末尾。这是最简单的搜索算法，适用于已排序和未排序的列表。
The pseudocode for linear search typically uses a WHILE loop or FOR loop. A flag variable can be set to indicate whether the item was found. In the worst-case scenario, the target might be the last element or not present at all, requiring n comparisons for a list of size n.
线性搜索的伪代码通常使用 WHILE 循环或 FOR 循环。可以设置一个标志变量来指示是否找到该项目。在最坏情况下，目标可能是最后一个元素或根本不存在，对于大小为 n 的列表需要 n 次比较。
While linear search is easy to implement, it can be inefficient for large datasets. Its time complexity in the worst case is O(n). Nevertheless, it is the only option when the data is unsorted.
虽然线性搜索易于实现，但对于大型数据集可能效率低下。它在最坏情况下的时间复杂度为 O(n)。然而，当数据未排序时，它是唯一的选择。
5. Binary Search | 二分搜索
Binary search is a much faster searching algorithm but it requires the list to be sorted beforehand. It repeatedly divides the search interval in half. If the middle element is the target, the search ends. If the target is smaller, the search continues on the left half; if larger, on the right half.
二分搜索是一种更快速的搜索算法，但要求列表事先已排序。它反复将搜索区间分成两半。如果中间元素是目标，搜索结束。如果目标更小，则在左半部分继续搜索；如果更大，则在右半部分继续。
The key variables are a lower bound (start) and an upper bound (end). The midpoint is calculated as (start + end) DIV 2. After each comparison, either the start or end is adjusted, effectively halving the search space.
关键变量是下界（start）和上界（end）。中点计算为 (start + end) DIV 2。每次比较后，调整 start 或 end，从而有效地将搜索空间减半。
Binary search is extremely efficient for large datasets, with a worst-case time complexity of O(log n). However, the extra cost of sorting might need to be considered if the data is not already sorted.
二分搜索对于大型数据集极其高效，最坏情况时间复杂度为 O(log n)。但是，如果数据未预先排序，则需考虑排序的额外成本。
6. Bubble Sort | 冒泡排序
Bubble sort is one of the simplest sorting algorithms. It repeatedly steps through the 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, which means the list is sorted.
冒泡排序是最简单的排序算法之一。它反复遍历列表，比较相邻元素，如果顺序错误则交换它们。遍历列表的过程会重复进行，直到没有交换发生，这意味着列表已排序。
In pseudocode, bubble sort uses two nested loops. The outer loop controls the number of passes, while the inner loop performs the comparisons and swaps. After each pass, the largest unsorted element ‘bubbles up’ to its correct position at the end of the list.
在伪代码中，冒泡排序使用两个嵌套循环。外层循环控制遍历次数，内层循环执行比较和交换。每次遍历后，最大的未排序元素会“冒泡”到列表末尾的正确位置。
Bubble sort is not efficient for large lists. Its worst-case and average time complexity are both O(n²). However, it is easy to understand and implement, making it a common introductory algorithm.
冒泡排序对于大型列表效率不高。它的最坏情况和平均时间复杂度均为 O(n²)。然而，它易于理解和实现，使其成为常见的入门算法。
7. Insertion Sort | 插入排序
Insertion sort builds the final sorted array one item at a time. It takes each element from the unsorted part and inserts it into its correct position within the sorted part. It is much more efficient than bubble sort for small datasets or nearly sorted data.
插入排序一次一个项目地构建最终有序数组。它从未排序部分取出每个元素，并将其插入到已排序部分的正确位置。对于小型数据集或接近有序的数据，它比冒泡排序高效得多。
The algorithm divides the list into a sorted section (initially just the first element) and an unsorted section. In each pass, the first element of the unsorted section is compared with elements in the sorted section, shifting them right if necessary, until the correct insertion point is found.
该算法将列表分为已排序部分（最初仅第一个元素）和未排序部分。在每轮中，未排序部分的第一个元素与已排序部分的元素进行比较，必要时将它们向右移动，直到找到正确的插入点。
Insertion sort has a worst-case time complexity of O(n²) but performs much better in practice for nearly sorted inputs, approaching O(n). It is a stable sort, meaning equal elements retain their relative order.
插入排序的最坏情况时间复杂度为 O(n²)，但对于接近有序的输入，实际性能要好得多，接近 O(n)。它是一种稳定排序，意味着相等元素保持其相对顺序。
8. Algorithm Efficiency: Time and Space | 算法效率：时间与空间
Algorithm efficiency is measured in terms of time complexity (how execution time grows with input size) and space complexity (how memory usage grows). IGCSE focuses on understanding that some algorithms are faster than others without requiring formal Big O notation, although awareness of linear vs quadratic growth is useful.
算法效率通过时间复杂度（执行时间如何随输入规模增长）和空间复杂度（内存使用如何增长）来衡量。IGCSE 侧重于理解某些算法比其他算法更快，而不要求正式的 Big O 表示法，但了解线性与平方增长的区别是有益的。
An algorithm that takes n steps for n items is said to have linear complexity. An algorithm with nested loops often takes about n² steps, which grows much faster. For example, binary search is logarithmic (much faster than linear), while bubble sort is quadratic.
对于 n 个项目需要 n 步的算法称为线性复杂度。具有嵌套循环的算法通常大约需要 n² 步，其增长速度要快得多。例如，二分搜索是对数级的（比线性快得多），而冒泡排序是平方级的。
When comparing algorithms, consider best-case, worst-case, and average-case scenarios. In IGCSE exams, you may be asked why one algorithm is more suitable than another for a given situation.
比较算法时，要考虑最好情况、最坏情况和平均情况。在 IGCSE 考试中，你可能会被问到为什么在给定的情况下某种算法比另一种更合适。
9. Common Algorithmic Errors | 常见算法错误
Algorithms can contain errors even if their logic seems sound. Common mistakes include off-by-one errors in loop counters, infinite loops where the termination condition is never met, and incorrect initialisation of variables, which leads to wrong results.
算法即使逻辑看似正确也可能包含错误。常见错误包括循环计数器中的差一错误、终止条件永远无法满足导致的无限循环，以及变量初始化错误，这会导致错误结果。
Another frequent issue is missing steps, such as forgetting to update a counter or not resetting a flag variable before reuse. In binary search, using the wrong midpoint formula can cause an infinite loop or skipped elements.
另一个常见问题是遗漏步骤，例如忘记更新计数器或在重用前未重置标志变量。在二分搜索中，使用错误的中点公式可能导致无限循环或跳过元素。
To identify errors, use trace tables to follow the algorithm step by step with sample data. This helps reveal logical flaws and confirm that the algorithm behaves as expected under all conditions.
要识别错误，可使用跟踪表通过样本数据逐步跟踪算法。这有助于揭示逻辑缺陷并确认算法在所有条件下均按预期运行。
10. Trace Tables | 跟踪表
A trace table is a manual technique to test an algorithm’s correctness. It records the values of variables at each step of execution. In IGCSE exams, you may be asked to complete a trace table to demonstrate how an algorithm works with given inputs.
跟踪表是一种手动测试算法正确性的技术。它记录执行每一步时变量的值。在 IGCSE 考试中，你可能会被要求完成一个跟踪表，以证明算法在给定输入下的工作原理。
To construct a trace table, create columns for each variable, condition, and output. Then execute the algorithm line by line, updating the values as they change. This allows you to spot logical errors and understand data flow.
要构建跟踪表，为每个变量、条件和输出创建列。然后逐行执行算法，在值变化时更新它们。这使你能够发现逻辑错误并理解数据流。
Trace tables are especially helpful for loops and conditional statements, where the state changes dynamically. Practice filling them in for searching and sorting algorithms to reinforce your understanding.
跟踪表对于循环和条件语句特别有用，因为状态会动态变化。为搜索和排序算法练习填写跟踪表，以加深理解。
11. Exam Tips for Algorithms | 算法考试技巧
When answering algorithm questions in IGCSE, read the problem carefully and identify the required inputs, outputs, and processes. Always use the correct pseudocode syntax shown in your syllabus, and label loop constructs clearly.
在 IGCSE 中回答算法问题时，仔细阅读问题并确定所需的输入、输出和处理过程。始终使用教学大纲中显示的正确伪代码语法，并清晰地标记循环结构。
In flowchart questions, use the standard symbols correctly and make sure arrows show the logical flow. For trace table questions, be methodical and update one step at a time. Show all working if asked to explain an algorithm’s efficiency.
在流程图问题中，正确使用标准符号并确保箭头显示逻辑流程。对于跟踪表问题，要有条不紊，一次更新一步。如果要求解释算法效率，请展示所有工作。
Common exam questions involve writing an algorithm to find the maximum, minimum, or average of a list, searching for an item, or sorting a small set of numbers. Practise these until you can write them confidently.
常见考试题目包括编写算法来查找列表的最大值、最小值或平均值，搜索某个项目或对一小组数字进行排序。练习这些直到你能自信地写出来。
Finally, remember to test your algorithm mentally with boundary cases (empty list, single element, duplicate values) to ensure it handles all scenarios. Time management is key – allocate your time based on mark weighting.
最后，记住在头脑中用边界情况（空列表、单个元素、重复值）测试你的算法，以确保它处理所有情况。时间管理是关键——根据分值权重分配时间。
Published by TutorHao | Computer Science Revision Series | aleveler.com
更多咨询请联系16621398022（同微信）
屏轩国际教育cambridge primary/secondary checkpoint, cat4, ukiset,ukcat,igcse,alevel,PAT,STEP,MAT, ibdp,ap,ssat,sat,sat2课程辅导，国外大学本科硕士研究生博士课程论文辅导