Algorithm Design and Problem-Solving Core Strategies | 算法设计与问题求解核心策略

📚 Algorithm Design and Problem-Solving Core Strategies | 算法设计与问题求解核心策略

In Computer Science, problem solving is not merely about finding an answer; it is about designing a clear, step-by-step procedure that a computer can follow reliably. This article examines the core strategies behind algorithm design and problem solving, aligned with the CIE syllabus, to help you approach exam questions with confidence.

在计算机科学中，问题求解不仅仅是找到答案，更在于设计一套清晰、逐步的流程，使计算机能够可靠地执行。本文围绕 CIE 考纲，深入探讨算法设计与问题求解的核心策略，帮助你在考试中从容应对各类题目。

1. Understanding the Problem | 理解问题

Before writing any algorithm, you must fully understand the problem. Ask yourself: what are the inputs, what are the expected outputs, and what constraints or special cases exist? A common mistake is to rush into coding before clarifying the requirements.

在编写任何算法之前，必须充分理解问题。请自问：输入是什么？预期输出是什么？存在哪些约束或特殊情况？常见的错误是在明确需求之前就匆忙开始编码。

Identify all inputs: values, types, and their ranges.

确定所有输入：数值、类型及其范围。
Identify all outputs: what the algorithm must produce.

确定所有输出：算法必须产生什么结果。
Note any edge cases, such as empty lists, negative numbers, or duplicate values.

注意边界情况，例如空列表、负数或重复值。

Example: “Find the largest number in a list” → Input: a list of integers; Output: a single integer.

示例：”找出列表中的最大数” → 输入：整数列表；输出：一个整数。

Once inputs, outputs, and constraints are clearly defined, you can design an algorithm that is correct and testable.

一旦明确了输入、输出和约束条件，你就能设计出正确且可测试的算法。

2. Decomposition | 问题分解

Decomposition means breaking a large, complex problem into smaller, more manageable sub-problems. Each sub-problem can be solved independently, and the solutions are then combined to form the complete solution.

问题分解是指将一个庞大而复杂的问题拆分成更小、更易管理的子问题。每个子问题可以独立解决，然后将各子问题的解组合起来形成完整方案。

Divide the task into logical modules or procedures.

将任务划分为逻辑模块或过程。
Solve each module separately, testing it in isolation.

单独解决每个模块，并独立测试。
Combine modules using a main program or control routine.

通过主程序或控制例程组合各模块。

For example, a program that calculates student grades can be decomposed into modules: input marks, calculate average, assign a grade, and display results. This makes the program easier to write, debug, and maintain.

例如，一个计算学生成绩的程序可以分解为多个模块：输入分数、计算平均值、评定等级和显示结果。这使得程序更易于编写、调试和维护。

3. Abstraction | 抽象

Abstraction involves removing unnecessary details while retaining only the essential features needed for the solution. It allows you to focus on what matters at each level of the design.

抽象是指去除无关紧要的细节，仅保留解决问题所必需的核心特征。它使你能够在设计的每个层面上专注于关键内容。

Represent real-world objects using variables and data structures.

使用变量和数据结构来表示现实世界中的对象。
Hide implementation details inside procedures or functions.

将实现细节隐藏在过程或函数内部。
Work with a high-level plan before dealing with low-level code.

先制定高层计划，再处理底层代码。

For instance, when simulating a traffic light, you do not need to model the physical bulb; you only need the states: red, amber, and green. This abstraction simplifies the algorithm considerably.

例如，在模拟红绿灯时，你无需模拟物理灯泡，只需考虑状态：红、黄、绿。这种抽象大大简化了算法。

4. Algorithmic Thinking | 算法思维

Algorithmic thinking is the ability to express a solution as a precise sequence of steps. Every algorithm must incorporate three basic control structures: sequence, selection, and iteration.

算法思维是以精确的步骤序列来表达解决方案的能力。每个算法都必须包含三种基本控制结构：顺序、选择和循环。

Control Structure	Description	控制结构	描述
Sequence	Statements executed one after another.	顺序	语句一条接一条地执行。
Selection	Chooses between alternatives using IF, CASE.	选择	使用 IF、CASE 在不同分支间进行选择。
Iteration	Repeats a block of code using FOR, WHILE, REPEAT.	循环	使用 FOR、WHILE、REPEAT 重复执行代码块。

Mastering these structures is fundamental. In CIE exams, you are often asked to read or write algorithms that use these constructs to solve a stated problem.

掌握这些结构是基础。在 CIE 考试中，你经常需要阅读或编写使用这些结构来解决问题的算法。

5. Pseudocode and Flowcharts | 伪代码与流程图

Pseudocode is an informal, human-readable description of an algorithm, written in a structured format. Flowcharts use graphical symbols to show the flow of control. Both are standard tools in the CIE syllabus for designing and communicating algorithms.

伪代码是一种非正式、人类可读的算法描述，以结构化格式书写。流程图使用图形符号来展示控制流程。两者都是 CIE 考纲中设计与表达算法的标准工具。

Use consistent keywords: INPUT, OUTPUT, IF…THEN…ELSE, FOR…TO, WHILE…DO.

使用一致的关键字：INPUT、OUTPUT、IF…THEN…ELSE、FOR…TO、WHILE…DO。
In flowcharts, use ovals for start/end, rectangles for processes, diamonds for decisions, and arrows for flow.

在流程图中，使用椭圆表示开始/结束，矩形表示处理，菱形表示判断，箭头表示流向。
Keep the level of detail consistent; each step should be a single clear action.

保持细节程度一致；每一步都应是单一清晰的操作。

For example, a pseudocode to find the sum of the first N positive integers could be written as follows:

例如，计算前 N 个正整数之和的伪代码可以这样写：

INPUT N
SET Sum = 0
FOR Count = 1 TO N
SET Sum = Sum + Count
ENDFOR
OUTPUT Sum

输入 N
令 Sum = 0
对于 Count = 1 到 N
令 Sum = Sum + Count
结束循环
输出 Sum

Flowcharts and pseudocode serve the same purpose; choose the one that makes the logic clearest for the problem at hand.

流程图和伪代码具有相同的目的；选择最能清晰表达当前问题逻辑的一种即可。

6. Searching Algorithms | 查找算法

Searching is a fundamental operation: given a list of items, find whether a target value exists and, if so, where it is located. Two classic algorithms are linear search and binary search.

查找是一项基本操作：给定一个数据列表，判断目标值是否存在，若存在则确定其位置。两种经典算法是线性查找和二分查找。

Linear Search checks each item in order, from the first to the last, until the target is found or the list ends. It works on both sorted and unsorted lists.

线性查找按顺序逐个检查列表中的每一项，直到找到目标或到达列表末尾。它适用于有序和无序列表。

Binary Search requires a sorted list. It repeatedly divides the search interval in half, comparing the middle element to the target and discarding the half that cannot contain the target.

二分查找要求列表必须有序。它反复将查找区间对半划分，将中间元素与目标比较，并丢弃不可能包含目标的那一半。

Linear Search comparisons: n (worst case)
Binary Search comparisons: log₂n (worst case)

线性查找比较次数：n（最坏情况）
二分查找比较次数：log₂n（最坏情况）

For a list of 1000 items, linear search may take 1000 comparisons, while binary search takes at most 10 comparisons. This illustrates why choosing the right algorithm matters.

对于包含 1000 项的数据，线性查找可能需要比较 1000 次，而二分查找最多只需 10 次。这说明了选择正确算法的重要性。

7. Sorting Algorithms | 排序算法

Sorting arranges data in a specified order, such as ascending or descending. The CIE syllabus focuses on three comparison-based sorts: bubble sort, insertion sort, and selection sort.

排序按指定顺序排列数据，例如升序或降序。CIE 考纲重点考查三种基于比较的排序：冒泡排序、插入排序和选择排序。

Bubble Sort repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. This is repeated until no swaps occur.

冒泡排序反复遍历列表，比较相邻元素，若顺序错误则交换它们。此过程重复进行，直到不再发生交换为止。

Insertion Sort builds the sorted list one element at a time, taking each new element and inserting it into its correct position among the already-sorted elements.

插入排序一次构建一个已排序元素，将每个新元素插入到已排序部分中的正确位置。

Selection Sort finds the smallest (or largest) remaining element in each pass and places it in its final position at the beginning (or end) of the list.

选择排序在每一轮中找出剩余元素中的最小（或最大）值，并将其放到列表开头（或末尾）的最终位置。

Algorithm	Time Complexity (Worst)	算法	时间复杂度（最坏）
Bubble Sort	O(n²)	冒泡排序	O(n²)
Insertion Sort	O(n²)	插入排序	O(n²)
Selection Sort	O(n²)	选择排序	O(n²)

All three have quadratic worst-case time complexity, but their behaviours differ on nearly-sorted data. Insertion sort often performs better in practice for small or partially sorted lists.

三种算法的最坏时间复杂度均为平方级，但在近乎有序的数据上表现不同。对于小型或部分有序的列表，插入排序在实践中通常表现更好。

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

Efficiency is concerned with how quickly an algorithm runs and how much memory it uses. Complexity is commonly expressed using Big O notation, which describes how the time or space grows as the input size n increases.

效率关注算法的运行速度和内存占用。复杂度通常使用大 O 记法表示，它描述了时间或空间随输入规模 n 增大的增长趋势。

O(1): constant time, independent of input size.

O(1)：常数时间，与输入规模无关。
O(n): linear time, proportional to input size.

O(n)：线性时间，与输入规模成正比。
O(n²): quadratic time, often from nested loops.

O(n²)：平方时间，通常来自嵌套循环。
O(log n): logarithmic time, typical of binary search.

O(log n)：对数时间，典型如二分查找。

When comparing algorithms, consider the size of the input and the worst-case scenario. A more efficient algorithm may be more complex to implement, so you must balance readability, correctness, and performance.

在比较算法时，需要考虑输入规模与最坏情况。更高效的算法可能实现起来更复杂，因此必须在可读性、正确性和性能之间取得平衡。

9. Testing and Debugging | 测试与调试

Testing is the process of running an algorithm with selected data to verify correctness. Debugging is the process of locating and fixing errors that the tests reveal. Both are essential parts of the problem-solving cycle.

测试是使用选定数据运行算法以验证正确性的过程。调试是定位并修复测试所暴露错误的过程。两者都是问题求解循环中不可或缺的环节。

Normal test data: typical values that the algorithm is expected to handle. Boundary test data: values at the limits of acceptable input, such as zero or the maximum size. Invalid test data: values that should be rejected, such as negative ages or non-numeric input.

正常测试数据：算法预期处理的典型值。边界测试数据：处于可接受输入极限的值，例如零或最大规模。无效测试数据：应被拒绝的值，例如负年龄或非数字输入。

A trace table is a powerful way to dry-run an algorithm manually. Each column represents a variable, and each row shows the state of all variables after each step.

跟踪表是手动运行算法的一种有力工具。每一列代表一个变量，每一行显示执行每一步后所有变量的状态。

Always test with all three categories of data, and use trace tables for short algorithms to capture logic errors before coding begins.

务必使用全部三类数据进行测试，并在编码前用跟踪表检查短算法的逻辑错误。

10. Common Problem-Solving Strategies | 常见问题求解策略

Several broad strategies can guide your approach to unfamiliar problems. Recognising when to apply each strategy is a key exam skill.

若干宏观策略可以指导你应对陌生问题。识别何时应用何种策略是一项关键考试技能。

Divide and conquer: break the problem into smaller independent parts, solve each, then combine. Example: merge sort and binary search.

分治法：将问题拆分为更小且相互独立的部分，分别求解后再合并。例如：归并排序和二分查找。
Backtracking: explore possible solutions and abandon a path as soon as it is known to fail. Example: solving a maze or the N-queens problem.

回溯法：探索可能的解，一旦确定某条路径失败就立即放弃。例如：走迷宫或 N 皇后问题。
Greedy approach: make the locally optimal choice at each step, hoping to reach a global optimum. Example: coin change with standard denominations.

贪心法：在每一步做出局部最优选择，期望达到全局最优。例如：使用标准面额找零。
Iterative refinement: start with a simple working solution, then gradually improve efficiency or clarity.

迭代改进：先给出一个简单可行的方案，再逐步提升效率或清晰度。

For CIE exam questions, first classify the problem: is it a search, a sort, a calculation, or a decision? Then choose a suitable strategy and express your solution clearly in pseudocode, a flowchart, or a structured description.

面对 CIE 考题时，首先对问题进行分类：是查找、排序、计算还是判断？然后选择合适的策略，并用伪代码、流程图或结构化描述清晰表达你的解决方案。

Finally, always verify your solution with a trace table and test data. This disciplined approach will reduce errors and earn full marks in algorithm-based questions.

最后，始终用跟踪表和测试数据验证你的解决方案。这种严谨的方法可以减少错误，并在算法类题目中帮助你获得满分。

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

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

Algorithm Design and Problem-Solving Core Strategies | 算法设计与问题求解核心策略