Tag: ccea

📚 IB CCEA Computer Science: Data Structures Key Points Review | IB CCEA 计算机：数据结构 考点精讲

Mastering data structures is essential for success in IB and CCEA Computer Science examinations. They form the backbone of efficient algorithm design and problem-solving, and candidates are expected not only to understand how each structure works but also to analyse their time and space complexities, choose appropriate implementations, and apply them to real-world computational problems. This article provides a comprehensive review of the key data structures covered in the syllabus, from arrays and linked lists to trees, graphs, and hash tables, with clear explanations and exam-focused insights.

掌握数据结构是 IB 和 CCEA 计算机科学考试中取得好成绩的关键。它们是高效算法设计与问题求解的基础，考生不仅要理解每种结构的工作原理，还需分析其时间与空间复杂度、选择合适的实现方式并应用于实际问题。本文系统梳理了考纲中的核心数据结构，包括数组、链表、栈、队列、树、图和哈希表，提供清晰的解释与应试导向的要点。

1. What are Data Structures? | 什么是数据结构？

A data structure is a specialised format for organising, processing, retrieving and storing data. In computer science, the right choice of data structure can dramatically affect the performance of an algorithm. Data structures can be classified as primitive (integers, floats, characters) and non-primitive, which are further divided into linear (arrays, linked lists, stacks, queues) and non-linear (trees, graphs). Understanding the distinction between static and dynamic structures, as well as the concept of Abstract Data Types (ADTs), sets the foundation for all subsequent topics.

数据结构是组织、处理、检索和存储数据的专用格式。在计算机科学中，正确选择数据结构可以显著影响算法的性能。数据结构可分为基本类型（整数、浮点数、字符）和非基本类型，后者进一步分为线性结构（数组、链表、栈、队列）和非线性结构（树、图）。理解静态与动态结构的区别以及抽象数据类型的概念，是学习后续所有主题的基础。

2. Arrays and Their Properties | 数组及其特性

An array is a static, contiguous block of memory that stores elements of the same data type. Each element is accessed directly via an index, allowing constant-time O(1) random access. This makes arrays highly efficient for look-up operations. However, insertion and deletion can be costly O(n) because elements may need to be shifted. In exam scenarios, you must be able to declare arrays, traverse them using loops, and implement basic operations such as searching (linear or binary if sorted) and sorting. Arrays can be one-dimensional or multi-dimensional, and their fixed size is a key limitation when the number of elements is unpredictable.

数组是一块静态、连续的内存区域，用于存储相同数据类型的元素。每个元素通过索引直接访问，可实现常数时间 O(1) 的随机存取，因此查找效率极高。但插入和删除操作可能达到 O(n) 的代价，因为可能需要移动元素。在考试中，你必须能够声明数组、使用循环遍历，并实现搜索（线性或基于排序的二分搜索）和排序等基本操作。数组可以是一维或多维的，其固定大小是当元素数量不可预测时的主要限制。

• Access: O(1)
• Search: O(n) (linear), O(log n) (binary if sorted)
• Insert/Delete at end: O(1) amortised; at arbitrary position: O(n)

访问：O(1)；搜索：O(n)（线性），如已排序则二分搜索为 O(log n)；插入/删除：在末尾为均摊 O(1)，在任意位置为 O(n)。

3. Linked Lists: Singly, Doubly and Circular | 链表：单链表、双链表和循环链表

A linked list is a dynamic data structure consisting of nodes, where each node contains data and a reference (or pointer) to the next node. Unlike arrays, linked lists do not require contiguous memory, and their size can grow or shrink at runtime. Singly linked lists allow forward traversal only; doubly linked lists have pointers to both previous and next nodes, enabling bidirectional traversal. Circular linked lists have the last node pointing back to the first. Key exam topics include node insertion/deletion at head, tail, or given position, searching, and reversing a list. While access is O(n) because you must traverse from the head, insertion and deletion at a known node can be O(1).

链表是一种动态数据结构，由节点组成，每个节点包含数据和指向下一节点的引用（或指针）。与数组不同，链表不需要连续的内存空间，其大小可以在运行时变化。单链表仅允许向前遍历；双链表具有指向前一个和后一个节点的指针，支持双向遍历；循环链表的最后一个节点指向头节点。考试重点包括在头部、尾部或指定位置插入与删除节点、搜索以及反转链表。由于必须从头遍历，访问为 O(n)，但在已知节点处的插入和删除可以是 O(1)。

Array vs Linked List comparison. | 数组与链表的对比。

4. Stacks: LIFO Principle | 栈：后进先出原则

A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle. All additions (push) and removals (pop) happen at the same end, called the top. Stacks can be implemented using arrays or linked lists; both give O(1) time for push and pop operations. Key applications include function call management (call stack), undo mechanisms in software, expression evaluation, and bracket matching. Examiners frequently ask for pseudocode to implement push, pop, peek/top, and isEmpty operations, as well as tracing stack contents after a sequence of commands.

栈是一种遵循后进先出（LIFO）原则的线性数据结构。所有添加（压入）和移除（弹出）操作都在同一端（称为栈顶）进行。栈可以用数组或链表实现；两种实现方式中，压入与弹出操作的时间复杂度均为 O(1)。主要应用包括函数调用管理（调用栈）、软件的撤销机制、表达式求值和括号匹配。考官经常要求编写实现压入、弹出、查看栈顶和判空操作的伪代码，以及跟踪执行一系列命令后栈的内容。

Push(x): top ← top + 1; stack[top] ← x
Pop(): if not empty: data ← stack[top]; top ← top – 1; return data

5. Queues: FIFO and Priority Queues | 队列：先进先出与优先队列

A queue is a linear data structure that operates on a First-In-First-Out (FIFO) basis. Elements are added at the rear (enqueue) and removed from the front (dequeue). Standard queues provide O(1) enqueue and dequeue. Circular queues use a fixed-size array and modulo arithmetic to reuse spaces efficiently. A priority queue extends the concept by associating each element with a priority; the highest-priority element is dequeued first regardless of insertion order. Implementations often use heaps for efficiency. Typical exam tasks include simulating queue operations, differentiating between linear and circular queues, and recognising real-world scenarios such as print spoolers, keyboard buffers, and process scheduling.

队列是一种基于先进先出（FIFO）原则的线性数据结构。元素在队尾入队，从队首出队。标准队列的入队和出队操作均为 O(1)。循环队列使用固定大小的数组和取模运算来高效重用空间。优先队列扩展了这一概念，为每个元素关联一个优先级；无论插入顺序如何，优先级最高的元素最先出队。实现通常使用堆以提高效率。典型考试任务包括模拟队列操作、区分线性队列与循环队列，以及辨别打印缓冲池、键盘缓冲区和进程调度等实际场景。

6. Trees: Binary Trees and Traversals | 树：二叉树与遍历

A tree is a hierarchical, non-linear data structure consisting of nodes connected by edges. Binary trees are a fundamental type where each node has at most two children (left and right). Important tree terminology includes root, leaf, parent, child, depth, and height. Binary search trees (BST) maintain ordering: for any node, left subtree values are smaller, right subtree values are larger, enabling efficient search, insertion, and deletion in O(log n) average time. Balanced trees (e.g., AVL) prevent degenerated O(n) performance. Tree traversals—pre-order, in-order, and post-order—are essential for processing tree data. Candidates must be able to perform these traversals recursively and iteratively, and to use them to output sorted sequences (in-order of BST) or reconstruct trees.

树是一种由节点和边构成的分层、非线性数据结构。二叉树是最基本的类型，每个节点最多有两个子节点（左和右）。重要的树术语包括根、叶、父节点、子节点、深度和高度。二叉搜索树（BST）维护顺序：对于任一节点，左子树的值较小，右子树的值较大，从而实现平均 O(log n) 时间的高效搜索、插入和删除。平衡树（如 AVL 树）防止退化为 O(n) 的性能。树的遍历——前序、中序和后序——是处理树数据的核心。考生必须能够递归和迭代地执行这些遍历，并能利用中序遍历输出有序序列（BST）或重建树结构。

Pre-order: Node → Left → Right
In-order: Left → Node → Right
Post-order: Left → Right → Node

7. Graphs: Representation and Basic Algorithms | 图：表示与基本算法

Graphs model pairwise relationships between objects using vertices (nodes) and edges. They can be directed or undirected, weighted or unweighted. Two primary representations are adjacency matrix (a 2D array where cell [i][j] indicates an edge) and adjacency list (an array of linked lists). Matrix offers O(1) edge queries but uses O(V²) space; lists are more space-efficient for sparse graphs O(V+E). Essential algorithms include breadth-first search (BFS) using a queue and depth-first search (DFS) using a stack or recursion. Both are used to explore connectivity, find paths, and detect cycles. For weighted graphs, Dijkstra’s algorithm finds shortest paths. Exam questions often ask to trace BFS/DFS, identify data structures used internally, and discuss applications such as social networks, routing, and web crawling.

图利用顶点（节点）和边来建模对象之间的成对关系。图可以是有向或无向的，带权或不带权。两种主要表示法是邻接矩阵（二维数组，单元格 [i][j] 指示边）和邻接表（链表的数组）。矩阵提供 O(1) 的边查询，但占用 O(V²) 空间；邻接表对稀疏图更节省空间，为 O(V+E)。核心算法包括使用队列的广度优先搜索（BFS）和使用栈或递归的深度优先搜索（DFS）。两者都用于探索连通性、寻找路径和检测环。对于带权图，Dijkstra 算法查找最短路径。考试题目常要求跟踪 BFS/DFS 的执行，识别内部使用的数据结构，并讨论社交网络、路由和网络爬虫等应用。

8. Hash Tables: Hashing and Collisions | 哈希表：哈希与冲突处理

A hash table (or hash map) stores key-value pairs and provides average-case O(1) insertion, deletion, and lookup. It uses a hash function to compute an index from the key. A good hash function minimises collisions and distributes keys uniformly. Collisions occur when different keys map to the same index; common resolution techniques include chaining (using a linked list at each bucket) and open addressing (probing the next available slot, e.g., linear probing, quadratic probing). Understanding load factor and rehashing is important for maintaining performance. In exam contexts, you may be asked to simulate a series of insertions given a specific hash function and collision strategy, or to evaluate the efficiency of a hash table against other structures for dictionary operations.

哈希表（或哈希映射）存储键值对，并提供平均情况 O(1) 的插入、删除和查找。它使用哈希函数从键计算索引。好的哈希函数能最小化冲突并均匀分布键。冲突发生在不同键映射到同一索引时；常见的解决技术包括链地址法（在每个桶使用链表）和开放寻址法（探测下一个可用槽，如线性探测、二次探测）。理解负载因子和再哈希对于维持性能至关重要。在考试中，可能要求你根据给定的哈希函数和冲突策略模拟一系列插入操作，或评估哈希表相对于其他结构在字典操作上的效率。

9. Abstract Data Types (ADT) and Implementation | 抽象数据类型及其实现

An Abstract Data Type defines a data type by its behaviour (operations) from the point of view of a user, specifically the possible values, the operations on them, and the behaviour of these operations. It is independent of any concrete implementation. For example, a Stack ADT specifies push, pop, top, and isEmpty operations without specifying whether it uses an array or linked list underneath. Understanding ADTs allows programmers to design modular code and swap implementations without changing the interface. In the IB and CCEA curricula, you should be able to differentiate between ADT and data structure, explain encapsulation and information hiding, and provide the operational specifications for common ADTs such as list, stack, queue, tree, and dictionary.

抽象数据类型（ADT）从用户角度通过行为（操作）来定义数据类型，具体包括可能的值、对这些值的操作以及这些操作的行为。它独立于任何具体实现。例如，栈 ADT 规定了 push、pop、top 和 isEmpty 操作，但不指定底层是使用数组还是链表。理解 ADT 使程序员能设计模块化代码，并在不改变接口的情况下交换实现。在 IB 和 CCEA 课程中，你需要区分 ADT 与数据结构，解释封装和信息隐藏，并为常见 ADT（如列表、栈、队列、树和字典）提供操作规范。

10. Choosing and Evaluating Data Structures | 数据结构的选择与评估

Selecting the optimal data structure for a given problem requires a careful analysis of the operations that will be performed most frequently and the resource constraints. Factors include time complexity, memory usage, ease of implementation, and specific requirements like ordering or fast range queries. For instance, an array is ideal for frequent random access and fixed-size collections, while a linked list suits scenarios with frequent insertions/deletions at arbitrary positions. A BST offers fast sorted data operations, but a hash table is preferable when only exact-match lookups are needed. Graphs are irreplaceable for network models. Being able to justify your choice in an exam, comparing at least two alternatives with Big-O notation, demonstrates deep understanding.

为给定问题选择最优数据结构，需要仔细分析最常执行的操作以及资源限制。因素包括时间复杂度、内存使用、实现难易度以及排序或快速范围查询等特殊要求。例如，数组适合频繁的随机访问和固定大小的集合，而链表适合在任意位置频繁插入/删除的场景。二叉搜索树可提供高效的排序数据操作，但若只需要精确匹配查找，哈希表更优。图在网络模型中不可替代。在考试中能够用大 O 符号比较至少两种备选方案并论证你的选择，体现了深刻的理解。

11. Exam Tips and Common Pitfalls | 考试技巧与常见错误

Data structure questions in IB and CCEA exams often involve tracing, pseudocode writing, and situational analysis. Always pay close attention to index boundaries in arrays (off-by-one errors) and pointer manipulation in linked lists (null pointer exceptions). When tracing recursion in tree traversal, label the output sequence clearly. Use diagrams to visualise tricky stack/queue states. Memorise the time complexities for common operations but understand the reasoning, as questions may ask for best/average/worst cases. For ADT questions, separate the interface from the implementation details. Finally, practise past paper questions on collision handling, BST insertion/deletion, and graph traversal to build speed and accuracy.

IB 和 CCEA 考试中的数据结构题目通常涉及跟踪、伪代码编写和场景分析。始终仔细检查数组中的索引边界（差一错误）和链表中的指针操作（空指针异常）。在跟踪树的递归遍历时，清晰地标注输出序列。使用图表可视化棘手的栈/队列状态。记住常见操作的时间复杂度，但要理解其原理，因为问题可能会询问最佳/平均/最坏情况。对于 ADT 问题，将接口与实现细节分开。最后，通过历年真题练习冲突处理、BST 插入/删除和图遍历，以提高速度和准确性。

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

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

📚 IB CCEA Computer Science: Typical Example Questions Explained | IB CCEA 计算机：典型例题详解

Understanding core concepts through worked examples is one of the most effective ways to prepare for IB and CCEA Computer Science exams. This article presents ten typical exam-style questions, each with step-by-step solutions, covering algorithm analysis, data structures, Boolean logic, finite state machines, SQL, object-oriented programming, recursion, scheduling, and networking. The bilingual explanations help you solidify both technical vocabulary and problem-solving strategies.

通过典型例题掌握核心概念是备考 IB 和 CCEA 计算机科学考试最有效的方法之一。本文精选十道常考题型，逐一给出详细解答，涵盖算法分析、数据结构、布尔逻辑、有限状态机、SQL、面向对象编程、递归、调度和网络等主题。中英双语讲解能同时巩固你的专业术语和解题思路。

1. Algorithmic Complexity: Big-O Notation | 算法复杂度：大O表示法

Question: Analyse the time complexity of the following pseudocode that searches for a target value in a sorted array using both a sequential scan and a binary search approach. Determine the best-case and worst-case Big-O.

题目：分析以下伪代码在有序数组中查找目标值的时间复杂度，分别给出顺序扫描和二分查找的最佳与最坏情况大O表示。

For a sequential scan over an array of n elements, the worst-case occurs when the target is at the final position or not present. The algorithm must examine all n elements, giving O(n). The best-case is O(1) when the target is at the first element.

对于含有 n 个元素的有序数组，顺序扫描的最坏情况是目标在最后一个位置或不存在，此时需要检查全部 n 个元素，复杂度为 O(n)。最佳情况是目标在第一个元素处，复杂度为 O(1)。

Binary search repeatedly halves the search space. In each step it compares the middle element. The worst-case number of steps is log₂ n, so the complexity is O(log n). The best-case is O(1) when the middle element matches immediately.

二分查找每次将搜索空间减半，每一步比较中间元素。最坏情况下最多需要 log₂ n 步，复杂度为 O(log n)。最佳情况是中间元素立即匹配，复杂度为 O(1)。

Remember that Big-O notation describes the upper bound of growth. When loops are nested, the complexities multiply; for two nested loops each iterating n times, the total is O(n²).

记住，大O表示法描述的是增长的上界。当循环嵌套时，复杂度相乘；若两个分别迭代 n 次的循环嵌套，总复杂度为 O(n²)。

2. Binary Search Tree Insertion and Traversals | 二叉搜索树插入与遍历

Question: Insert the following keys in order into an initially empty binary search tree (BST): 50, 30, 70, 20, 40, 60, 80. Then list the nodes visited during pre-order, in-order, and post-order traversals.

题目：将以下键值按顺序插入一棵初始为空的二叉搜索树：50, 30, 70, 20, 40, 60, 80。然后列出先序、中序和后序遍历所访问的节点。

The BST property ensures that for any node, all keys in its left subtree are smaller and all keys in the right subtree are larger. In-order traversal always yields keys in ascending order, which is a key characteristic often tested in exams.

BST 的性质保证任意节点的左子树中的所有键值都比该节点小，右子树中的所有键值都比该节点大。中序遍历总是按升序输出键值，这是考试中常考的一个重要特点。

3. Boolean Algebra Simplification Using Laws and Karnaugh Maps | 布尔代数化简：使用定律与卡诺图

Question: Simplify the Boolean expression F = A·B’ + A·B + A’·B. Verify your result using a 2-variable Karnaugh map.

题目：化简布尔表达式 F = A·B’ + A·B + A’·B，并使用二变量卡诺图验证结果。

Apply the consensus and absorption laws: A·B’ + A·B = A·(B’ + B) = A·1 = A. Now F = A + A’·B. Using the distributive law: A + A’·B = (A + A’)·(A + B) = 1·(A + B) = A + B.

应用吸收律和一致律：A·B’ + A·B = A·(B’ + B) = A·1 = A。此时 F = A + A’·B。再使用分配律：A + A’·B = (A + A’)·(A + B) = 1·(A + B) = A + B。

In a 2-variable Karnaugh map with rows for A and columns for B, place 1s in cells corresponding to minterms A·B’ (10), A·B (11), and A’·B (01). The cell A’·B’ (00) contains 0. Grouping the three 1s yields two prime implicants: the group covering (10, 11) gives A, and the group covering (01, 11) gives B. The simplified expression is A + B.

在二变量卡诺图中（行 A，列 B），将 1 填入与最小项对应的单元格：A·B’ (10)、A·B (11) 和 A’·B (01)，A’·B’ (00) 填入 0。将三个 1 分组得到两个质蕴含项：覆盖 (10, 11) 的组给出 A，覆盖 (01, 11) 的组给出 B。化简结果为 A + B。

4. Logic Circuit Design from a Truth Table | 根据真值表设计逻辑电路

Question: A combinational circuit has three inputs X, Y, Z and one output F. F is 1 when exactly two inputs are 1, or when all three inputs are 0. Derive the Sum-of-Products (SOP) expression, simplify it, and sketch the gate-level diagram.

题目：某组合电路有三个输入 X、Y、Z，一个输出 F。当恰好有两个输入为 1，或所有输入均为 0 时，F = 1。写出最小项之和（SOP）表达式，化简并画出门级电路图。

SOP: F = X’·Y’·Z’ + X’·Y·Z + X·Y’·Z + X·Y·Z’. This expression cannot be further simplified by Boolean algebra easily, but a Karnaugh map shows no adjacent 1s except that the zero combination is isolated. The simplified expression is actually the XOR and XNOR combination: F = (X ⊕ Y ⊕ Z)’. Alternatively, F = (X ≡ Y ≡ Z), which can be built using two XOR gates and one NOT.

SOP 表达式：F = X’·Y’·Z’ + X’·Y·Z + X·Y’·Z + X·Y·Z’。该表达式通过布尔代数不易进一步化简，但卡诺图显示除了全零项外没有相邻的 1。实际上 F = (X ⊕ Y ⊕ Z)’，可以表示为 F = (X ≡ Y ≡ Z)，用两个异或门和一个非门即可实现。

The circuit consists of an XOR gate taking X and Y, whose output feeds a second XOR gate together with Z. The output of the second XOR is then inverted to produce F.

电路由一个异或门处理 X 和 Y，其输出与 Z 共同接入第二个异或门，第二个异或门的输出再经反相得到 F。

5. Finite State Machine: Sequence Detector for ‘1101’ | 有限状态机：序列 ‘1101’ 检测器

Question: Design a Moore FSM that detects the overlapping sequence ‘1101’ in a serial input stream. Draw the state transition diagram and write the state transition table.

题目：设计一个 Moore 型有限状态机，检测串行输入流中的重叠序列 ‘1101’。画出状态转移图，并写出状态转移表。

We need five states: S0 (reset/no match), S1 (detected ‘1’), S2 (detected ’11’), S3 (detected ‘110’), S4 (detected ‘1101’ output = 1). Overlapping is allowed, so from S4 on input 1 the next state is S2 (because the last two bits become ’11’), and on input 0 it goes to S1.

需要五个状态：S0（复位/无匹配）、S1（检测到 ‘1’）、S2（检测到 ’11’）、S3（检测到 ‘110’）、S4（检测到 ‘1101’ 输出 = 1）。由于允许重叠，从 S4 在输入为 1 时下一状态为 S2（因为最后两位变为 ’11’），输入为 0 时转至 S1。

The output is 1 only in S4, indicating the sequence has been detected. This FSM correctly handles overlapping sequences such as ‘1101101’ where the second detection starts before the first ends.

输出仅在 S4 状态为 1，表示检测到目标序列。该 FSM 能正确处理重叠序列，例如对于输入 ‘1101101’，第二个检测在第一个检测结束之前即已开始。

6. SQL Query Writing with JOINs | 使用 JOIN 编写 SQL 查询

Question: Given two tables: Students(StudentID, Name, Major) and Enrolments(StudentID, CourseCode, Grade). Write SQL queries to (a) list all students enrolled in the ‘Computer Science’ major and their courses, (b) find the average grade for each course, and (c) identify students who have not enrolled in any course.

题目：给定两张表：Students(StudentID, Name, Major) 和 Enrolments(StudentID, CourseCode, Grade)。编写 SQL 查询实现：(a) 列出所有主修 ‘Computer Science’ 的学生及其所选课程；(b) 计算每门课的平均成绩；(c) 找出未选修任何课程的学生。

(a) SELECT s.Name, e.CourseCode FROM Students s INNER JOIN Enrolments e ON s.StudentID = e.StudentID WHERE s.Major = ‘Computer Science’; The INNER JOIN ensures only students with enrolment records appear.

(a) SELECT s.Name, e.CourseCode FROM Students s INNER JOIN Enrolments e ON s.StudentID = e.StudentID WHERE s.Major = ‘Computer Science’; 使用 INNER JOIN 确保只返回有选课记录的学生。

(b) SELECT e.CourseCode, AVG(e.Grade) AS AvgGrade FROM Enrolments e GROUP BY e.CourseCode; The AVG function calculates the mean, and GROUP BY aggregates per course. NULL grades are typically ignored.

(b) SELECT e.CourseCode, AVG(e.Grade) AS AvgGrade FROM Enrolments e GROUP BY e.CourseCode; AVG 函数计算平均值，GROUP BY 按课程分组。通常忽略 NULL 值的成绩。

(c) SELECT s.Name FROM Students s LEFT JOIN Enrolments e ON s.StudentID = e.StudentID WHERE e.StudentID IS NULL; A LEFT JOIN includes all students; filtering for NULL in the enrolment side finds those without any course.

(c) SELECT s.Name FROM Students s LEFT JOIN Enrolments e ON s.StudentID = e.StudentID WHERE e.StudentID IS NULL; 左连接保留所有学生，筛选入学记录为 NULL 即可找出未选课的学生。

7. Object-Oriented Programming: Designing a BankAccount Class | 面向对象编程：BankAccount 类设计

Question: Design a Java/Python-like BankAccount class encapsulating balance, with methods deposit(amount), withdraw(amount), and getBalance(). Ensure that withdraw imposes a minimum balance constraint of 0. Explain the principles of encapsulation and data hiding.

题目：设计一个类似 Java/Python 的 BankAccount 类，封装余额属性，提供 deposit(amount)、withdraw(amount) 和 getBalance() 方法，要求 withdraw 时确保余额不低于 0。阐述封装和数据隐藏原理。

class BankAccount:
    def __init__(self, initial=0):
        self.__balance = initial   # private attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def getBalance(self):
        return self.__balance

The double underscore prefix (__balance) makes the attribute private, preventing direct external modification. Access is forced through public methods, which can enforce validation rules. This is the core of encapsulation: internal state is protected, and the class maintains its own invariants.

双下划线前缀（__balance）将属性设为私有，阻止外部直接修改。只能通过公有方法访问，从而执行验证规则。这就是封装的核心：内部状态受保护，类自行维护其不变量。

Data hiding ensures that changes to the internal representation do not affect external code that uses the class, as long as the public interface remains consistent. This reduces coupling and improves maintainability.

数据隐藏确保，只要公有接口保持一致，内部表示的改变就不会影响使用该类的外部代码，从而降低耦合度、提高可维护性。

8. Recursive Problem Solving: Fibonacci Sequence and Time Complexity | 递归问题求解：斐波那契数列与时间复杂度

Question: Implement a recursive function fib(n) that returns the n-th Fibonacci number. Analyse its time complexity and explain why memoization or iteration is preferred for large n.

题目：实现一个递归函数 fib(n) 返回第 n 个斐波那契数。分析其时间复杂度，并解释为何对较大的 n 更推荐记忆化或迭代。

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

The recurrence T(n) = T(n-1) + T(n-2) + O(1) solves to O(2^n), because the function recomputes the same subproblems many times, creating an exponential explosion.

递推关系 T(n) = T(n-1) + T(n-2) + O(1) 的解为 O(2^n)，因为该函数多次重复计算相同的子问题，造成指数级爆炸。

With memoization (caching results in a dictionary), each fib(k) is computed only once, reducing the complexity to O(n). Alternatively, an iterative approach using two variables also achieves O(n) time and O(1) space. This demonstrates the importance of avoiding naive recursion for problems with overlapping subproblems.

采用记忆化（使用字典缓存结果）时，每个 fib(k) 只计算一次，复杂度降为 O(n)。另一种迭代方法使用两个变量，也可实现 O(n) 时间和 O(1) 空间。这表明对有重叠子问题的情况应避免简单递归。

9. Scheduling Algorithms: Round Robin with Context Switch Overhead | 调度算法：带上下文切换开销的轮转法

Question: Three processes P1, P2, P3 arrive at time 0 with service times 10, 5, and 8 ms respectively. Using Round Robin scheduling with a time quantum of 4 ms and context switch overhead of 2 ms, compute the average waiting time and draw the Gantt chart.

题目：三个进程 P1、P2、P3 均在时间 0 到达，服务时间分别为 10、5、8 ms。采用时间片为 4 ms、上下文切换开销为 2 ms 的轮转调度，计算平均等待时间并画出甘特图。

Execution order (including context switch intervals CS): CS(2) → P1(4) → CS(2) → P2(4) → CS(2) → P3(4) → CS(2) → P1(4) → CS(2) → P2(1) → CS(2) → P3(4) → CS(2) → P1(2). Context switches before the first process and after the last are not counted by convention, but we include them as they add overhead. Waiting time for P1: starts at 2, runs 4, then waits until its next turn at time 2+4+2+4+2+4+2 = 20, so total wait = (2-0) + (20-6) = 2+14 = 16 ms. Finish time = 36. Similar for others.

执行顺序（含上下文切换 CS 间隔）：CS(2) → P1(4) → CS(2) → P2(4) → CS(2) → P3(4) → CS(2) → P1(4) → CS(2) → P2(1) → CS(2) → P3(4) → CS(2) → P1(2)。按惯例不计算首个进程之前和最后一个进程之后的切换，但这里我们将其视为额外开销。P1 的等待时间：从时间 2 开始运行 4 后，下一次轮到在 2+4+2+4+2+4+2=20，所以等待总长 = (2-0)+(20-6)=2+14=16 ms。完成时间 36。其余类推。

Average waiting time = (16+18+18)/3 ≈ 17.33 ms. Context switches significantly increase wait times; without overhead the average wait would be around 12-13 ms.

平均等待时间 = (16+18+18)/3 ≈ 17.33 ms。上下文切换显著增加了等待时间；若无此开销，平均等待时间约在 12-13 ms 左右。

10. Network Protocols: TCP vs UDP and the Three-Way Handshake | 网络协议：TCP 与 UDP 及三次握手

Question: Compare TCP and UDP in terms of reliability, ordering, and connection setup. Explain the three-way handshake used by TCP to establish a connection, and give one application scenario for each protocol.

题目：从可靠性、顺序性和连接建立方面比较 TCP 和 UDP。解释 TCP 建立连接的三次握手过程，并各举一个适用场景。

TCP is connection-oriented: it uses a three-way handshake (SYN, SYN-ACK, ACK) to set up a reliable channel. It guarantees delivery through acknowledgments and retransmissions, and preserves data order using sequence numbers. UDP is connectionless with no handshake; it does not guarantee delivery or order, making it faster and lighter.

TCP 面向连接：通过三次握手（SYN、SYN-ACK、ACK）建立可靠通道。它通过确认与重传保证交付，使用序号保持数据顺序。UDP 无连接、无握手，不保证交付或顺序，因此更快、开销更小。

Three-way handshake steps: (1) Client sends SYN with random sequence number x. (2) Server replies with SYN-ACK containing its own sequence number y and acknowledging x+1. (3) Client sends ACK with acknowledgment y+1. Only then is the connection established and data transfer begins.

三次握手步骤：(1) 客户端发送带有随机序号 x 的 SYN。(2) 服务器回复 SYN-ACK，包含自己的序号 y 并确认 x+1。(3) 客户端发送确认 y+1 的 ACK。连接至此建立，开始传输数据。Published by TutorHao | IB Computer Science Revision Series | aleveler.com

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

📚 IB CCEA Computer Science: Programming Fundamentals Revision Guide | IB CCEA 计算机科学：编程基础考点精讲

Programming fundamentals form the bedrock of any computer science curriculum, and mastering these concepts is essential for success in IB and CCEA examinations. This guide breaks down the key areas you need to understand: from variables and data types to control structures, arrays, functions, and basic algorithmic thinking. Each section provides clear explanations, practical examples, and common pitfalls to avoid, ensuring you can tackle both written theory questions and practical programming tasks with confidence.

编程基础是任何计算机科学课程的基石，掌握这些概念对于在 IB 和 CCEA 考试中取得成功至关重要。本指南将逐一解析你需要掌握的核心领域：从变量和数据类型到控制结构、数组、函数以及基本的算法思维。每个部分都提供清晰的解释、实用的示例以及需要避免的常见陷阱，确保你能够自信地应对理论笔试和编程实践任务。

1. Variables and Constants | 变量与常量

In programming, a variable is a named storage location in memory that holds a value which can change during the execution of a program. A constant, on the other hand, is a named memory location whose value cannot be altered once it has been assigned. When you declare a variable, you specify its identifier (name) and the type of data it will store. Good naming conventions, such as using camelCase or snake_case, make code more readable and maintainable. For example, int studentAge = 17; declares an integer variable, while final double PI = 3.14159; creates a constant. In pseudocode often used in IB and CCEA papers, constants are typically declared with a keyword like CONST. Understanding the scope of a variable—whether it is local to a function or global—is also crucial. A local variable exists only within the block where it is declared, preventing unintended side effects. Global variables, accessible from anywhere in the program, can lead to confusing bugs and are generally discouraged.

在编程中，变量是内存中的一个命名存储位置，其值在程序执行期间可以改变。而常量是一个命名的内存位置，一旦被赋值后其值就不可更改。声明变量时，你需要指定它的标识符（名称）以及即将存储的数据类型。良好的命名惯例，例如使用驼峰命名法或下划线命名法，能使代码更具可读性和可维护性。例如，int studentAge = 17; 声明了一个整型变量，而 final double PI = 3.14159; 则创建了一个常量。在 IB 和 CCEA 试卷常用的伪代码中，常量通常用类似 CONST 的关键词来声明。理解变量的作用域——它是函数局部变量还是全局变量——也至关重要。局部变量仅存在于声明它的代码块内部，从而防止产生意外的副作用。全局变量在程序的任何地方都可访问，容易导致难以排查的错误，因此通常不推荐使用。

2. Data Types and Type Systems | 数据类型与类型系统

Every value in a program belongs to a data type, which defines the operations that can be performed on it and the amount of memory it occupies. The most common primitive types are integer, float (or real), Boolean, and character. An integer holds whole numbers, a float stores numbers with a decimal point, a Boolean represents true or false, and a character holds a single symbol like ‘A’ or ‘5’. Strings, though not a primitive type in many languages, are sequences of characters and are heavily tested. Type systems can be static or dynamic. In a statically typed language like Java or C#, you must declare the type explicitly; the compiler checks for type mismatches before the program runs. Dynamically typed languages such as Python determine the type at runtime, offering flexibility but potentially introducing type-related errors that only appear during execution. A key skill in exams is choosing the appropriate data type for a given piece of data, and knowing when type casting (converting one type to another) is required, such as parsing an integer from a string input.

程序中的每个值都隶属于一种数据类型，它定义了可以对该值执行的操作以及所占用的内存空间。最常见的基本数据类型有整型、浮点型（或实型）、布尔型和字符型。整型存放整数，浮点型存放带小数点的数字，布尔型表示 true 或 false，而字符型则存放如 ‘A’ 或 ‘5’ 这样的单个符号。字符串在许多语言中虽不属于基本类型，但是由字符组成的序列，是考试重点。类型系统可以是静态的或动态的。在像 Java 或 C# 这样的静态类型语言中，你必须显式声明类型；编译器会在程序运行前检查类型是否匹配。像 Python 这样的动态类型语言则在运行时确定类型，提供了灵活性，但也可能引入仅在执行时才会显现的类型相关错误。考试中的一项关键技能，就是为给定的数据选择合适的数据类型，并知晓何时需要进行类型转换（将一种类型转换为另一种类型），例如从字符串输入中解析出一个整数。

3. Input and Output Operations | 输入与输出操作

Interacting with the user is a fundamental requirement of most programs. Input operations read data from an external source, such as a keyboard, a file, or a sensor. Output operations send data to a destination like a screen, a printer, or a network socket. In IB and CCEA pseudocode, input is often represented by statements such as input variableName or variableName ← USERINPUT. Output uses OUTPUT "message" or PRINT. When reading input, you must always consider data types: input received from a user is typically a string, so if you need an integer or a float, you must convert it. Error handling for invalid input is a common exam topic. For instance, if a user enters ‘abc’ when a number is expected, the program should not crash but instead display a polite error message and perhaps ask again. Screen output should be formatted clearly, for example using newline characters or tab spacing. The ability to trace a piece of pseudocode that mixes input, output, and simple calculations is regularly tested, so practice dry-running code manually.

与用户交互是大多数程序的基本要求。输入操作从外部来源读取数据，例如键盘、文件或传感器。输出操作将数据发送到如屏幕、打印机或网络套接字这类目标。在 IB 和 CCEA 的伪代码中，输入通常用 input variableName 或 variableName ← USERINPUT 这类语句表示。输出则使用 OUTPUT "message" 或 PRINT。在读取输入时，你必须始终考虑数据类型：从用户获取的输入通常是字符串，因此如果需要整型或浮点型数据，就必须进行转换。对无效输入的错误处理是常见的考题主题。例如，当用户输入 ‘abc’ 却期望一个数字时，程序不应崩溃，而是应显示一条友好的错误提示，并可能再次请求输入。屏幕输出应格式清晰，比如使用换行符或制表符空格。同时混合使用输入、输出和简单计算的伪代码追踪能力是经常考查的，所以要多手动进行代码纸笔执行练习。

4. Arithmetic and Comparison Operators | 算术与比较运算符

Operators are symbols that perform operations on one or more operands. Arithmetic operators include + (addition), - (subtraction), * (multiplication), / (division), and often MOD (modulus, which returns the remainder of integer division) and DIV (integer division). The order of operations (precedence) follows the standard mathematical rules: parentheses first, then multiplication, division, and modulus before addition and subtraction. Understanding modulus is particularly important for tasks like checking whether a number is even or odd (num MOD 2 == 0) or wrapping around an array index. Comparison operators evaluate to a Boolean value: == or = (equal to), != or <> (not equal to), > (greater than), < (less than), >= (greater than or equal to), and <= (less than or equal to). In many exam pseudocode notations, the assignment operator is ←, while equality comparison uses a single =, which differs from many programming languages where = is assignment and == is equality. Always check the specific notation specified in the question paper.

运算符是对一个或多个操作数执行操作的符号。算术运算符包括 +（加）、-（减）、*（乘）、/（除），通常还有 MOD（取模，返回整数除法后的余数）和 DIV（整除）。运算顺序（优先级）遵循标准数学规则：括号优先，然后乘、除和取模，最后加和减。理解取模运算尤其重要，比如用于检查一个数是否为偶数或奇数（num MOD 2 == 0），或者处理数组索引回绕。比较运算符的计算结果为一个布尔值：== 或 =（等于）、!= 或 <>（不等于）、>（大于）、<（小于）、>=（大于等于）、以及 <=（小于等于）。在许多考试的伪代码表示法中，赋值运算符用 ←，而相等比较使用单个 =，这与许多编程语言中 = 是赋值而 == 是相等比较有所不同。务必检查试卷中指定的具体表示法。

5. Selection Constructs: IF and CASE | 选择结构：IF 与 CASE

Selection allows a program to choose between different paths based on conditions. The most basic form is the simple IF ... THEN ... ENDIF structure. A more complete version includes IF condition THEN ... ELSE ... ENDIF, and for multiple conditions, IF ... THEN ... ELSE IF ... THEN ... ELSE ... ENDIF. In the CCEA and IB pseudocode style, the condition is a Boolean expression, and indentation is used to show the block of statements belonging to each branch. Nested IF statements are permitted but should be used with care to avoid deep nesting, which can harm readability. An alternative for multiple discrete values is the CASE or SWITCH statement. Instead of writing many IF-ELSE branches testing the same variable against different values, a CASE structure provides a cleaner way: CASE OF variable: value1: ... value2: ... OTHERWISE: ... ENDCASE. Remember that the cases are checked in order, and the OTHERWISE clause handles any value not explicitly listed. Efficient use of Boolean operators (AND, OR, NOT) within conditions is crucial for constructing complex logic.

选择结构允许程序根据条件在不同的路径间进行选择。最基本的形式是简单的 IF ... THEN ... ENDIF 结构。更完整的版本包括 IF condition THEN ... ELSE ... ENDIF，而针对多个条件，则有 IF ... THEN ... ELSE IF ... THEN ... ELSE ... ENDIF。在 CCEA 和 IB 的伪代码风格中，条件是一个布尔表达式，并使用缩进来标明属于每个分支的语句块。嵌套的 IF 语句是允许的，但应谨慎使用以避免深层嵌套，这会损害可读性。当面对多个离散值的情况时，另一种选择是 CASE 或 SWITCH 语句。与其写出许多针对同一变量不同值的 IF-ELSE 分支，CASE 结构提供了一种更简洁的方式：CASE OF variable: value1: ... value2: ... OTHERWISE: ... ENDCASE。注意，分支是按顺序检查的，并且 OTHERWISE 子句会处理任何未明确列出的值。在条件中高效地使用布尔运算符（AND、OR、NOT）对于构建复杂逻辑至关重要。

6. Iteration: Count-Controlled and Condition-Controlled Loops | 迭代：计数控制与条件控制循环

Programs often need to repeat a block of code. There are three main loop types to know. A count-controlled loop (FOR loop) repeats a set number of times. In pseudocode: FOR index ← 1 TO 10 ... NEXT index. You can specify a step value if you want to increment by something other than 1. The loop variable should not be modified inside the loop body. Condition-controlled loops come in two flavours: the WHILE loop checks the condition before each iteration, so the body may execute zero times. The REPEAT…UNTIL loop checks the condition after the body, guaranteeing at least one execution. Example: WHILE userGuess != secretNumber DO ... ENDWHILE versus REPEAT ... UNTIL userGuess = secretNumber. Infinite loops occur when the termination condition is never met; these are often logic errors unless intentionally implemented for event-driven programs. Nested loops—one loop inside another—are powerful for working with 2D data structures like tables or grids. Trace tables are an indispensable tool for stepping through loops and verifying the values of variables at each iteration. Be meticulous with loop boundaries; off-by-one errors are a frequent exam mistake.

程序经常需要重复执行一段代码。你需要了解三种主要的循环类型。计数控制循环（FOR 循环）会重复执行指定次数。在伪代码中：FOR index ← 1 TO 10 ... NEXT index。如果你想以非 1 的步长递增，可以指定步长值。循环变量不应在循环体内部被修改。条件控制循环有两种形式：WHILE 循环在每次迭代前检查条件，因此循环体可能一次也不执行。REPEAT…UNTIL 循环则是在循环体执行后检查条件，从而保证至少执行一次。例如：WHILE userGuess != secretNumber DO ... ENDWHILE 对比 REPEAT ... UNTIL userGuess = secretNumber。当终止条件永远无法满足时，就会出现无限循环；除非有意为事件驱动程序实现，否则这通常是逻辑错误。嵌套循环——一个循环内部套着另一个循环——在处理诸如表格或网格这样的二维数据结构时功能强大。追踪表是逐步执行循环并在每次迭代时验证变量值的不可或缺的工具。对循环边界要一丝不苟；“差一”错误是考试中常见的失误。

7. Arrays and Lists | 数组与列表

An array is a data structure that stores a collection of elements of the same data type, each accessible by an index. In most exam pseudocode, arrays are zero-indexed, meaning the first element is at index 0. You might see declarations like ARRAY scores[5] for a static array of five integers, or dynamic lists that can grow and shrink. Operations include initialisation, accessing an element (scores[2]), assignment, and traversal using a loop. A common pattern is using a FOR loop to iterate from 0 to length-1 to process each element. Multi-dimensional arrays, especially 2D arrays, are used to represent grids, game boards, or relational data. Searching an array—linear search for unsorted data, binary search for sorted data—is a classic algorithm you must be able to trace and code. It is also important to understand when to use an array versus a simple list or record structure. Inserting or deleting elements from an array can be costly because shifting of subsequent elements may be necessary, which is why linked lists are presented as an alternative in more advanced topics.

数组是一种数据结构，它存储一组相同数据类型的元素，每个元素都可通过索引进行访问。在大多数考试的伪代码中，数组采用零索引，即第一个元素位于索引 0 处。你可能会看到像 ARRAY scores[5] 这样的声明，表示一个包含五个整数的静态数组，或者看到能够增长和收缩的动态列表。数组的操作包括初始化、访问元素（scores[2]）、赋值以及使用循环进行遍历。一种常见的模式是使用 FOR 循环从 0 遍历到 length-1 来处理每个元素。多维数组，特别是二维数组，用于表示网格、游戏棋盘或关系数据。搜索数组——对未排序数据进行线性搜索，对已排序数据进行二分搜索——是经典算法，你必须能够追踪和写出相应的代码。理解何时使用数组而非简单的列表或记录结构也很重要。在数组中插入或删除元素可能会很耗时，因为可能需要移动后续元素，这也正是链式列表在更进阶的主题中作为替代方案被提出的原因。

8. Strings and String Manipulation | 字符串及其操作

Strings are sequences of characters and are treated as a single data type in many high-level languages, although conceptually they are like arrays of characters. Common string operations tested include concatenation (joining two strings with + or &), finding the length of a string (LEN(str) or str.length), extracting substrings (SUBSTRING(str, start, length)), and converting between uppercase and lowercase. Character-level access using an index is also fundamental, allowing you to loop through a string to count vowels, check for palindromes, or perform pattern matching. Input validation often requires checking that a string contains only digits, letters, or follows a certain format like an email address. In pseudocode, string comparisons are case-sensitive, so converting to a uniform case before comparing is a standard technique. Efficient string building inside loops can be a subtle topic: repeatedly concatenating with + in a loop may create many intermediate string objects in some languages, but for exam purposes, you mainly need to demonstrate correct logic.

字符串是字符的序列，在许多高级语言中被视为单一数据类型，尽管从概念上讲它们类似于字符的数组。经常考查的字符串操作包括：拼接（用 + 或 & 连接两个字符串）、获取字符串长度（LEN(str) 或 str.length）、提取子串（SUBSTRING(str, start, length)），以及大小写转换。使用索引进行字符级访问也是基础操作，允许你遍历字符串以统计元音字母数量、检查回文或执行模式匹配。输入验证通常需要检查字符串是否只包含数字、字母，或者是否符合诸如电子邮件地址的特定格式。在伪代码中，字符串比较是区分大小写的，因此在比较前转换为统一的大小写是一种标准技巧。循环内部构建字符串的效率可能是一个微妙的议题：在某些语言中，在循环内反复使用 + 进行拼接可能会创建许多中间字符串对象，但就考试而言，你主要需要展现出正确的逻辑。

9. Functions and Procedures | 函数与过程

Modular programming is a key concept for managing complexity. A procedure is a named block of code that performs a specific task but does not return a value. A function also performs a task but returns a single value (or a reference) to the caller. In pseudocode, you might see PROCEDURE displayMenu() ... ENDPROCEDURE and FUNCTION sum(a, b) RETURNS INTEGER ... ENDFUNCTION. Parameters allow data to be passed into these subprograms. There are two main parameter passing mechanisms: passing by value, where a copy of the argument is made and changes inside the subprogram do not affect the original variable; and passing by reference, where the memory address is passed so modifications directly affect the original. The scope of variables declared inside a function is local to that function, which helps prevent unintended interference between different parts of a program. Well-designed functions should do one thing and do it well, have a meaningful name, and avoid side effects. Recursion—a function that calls itself—is a topic that appears in higher-level papers and must be traced carefully using a stack of activation records.

模块化编程是管理复杂性的关键概念。过程是一个命名代码块，执行特定任务但不返回值。函数同样执行任务，但会向调用者返回一个单一的值（或引用）。在伪代码中，你可能会看到 PROCEDURE displayMenu() ... ENDPROCEDURE 和 FUNCTION sum(a, b) RETURNS INTEGER ... ENDFUNCTION。参数允许将数据传入这些子程序。有两种主要的参数传递机制：按值传递，此时会创建实参的一个副本，子程序内部对副本的修改不会影响原始变量；按引用传递，此时传递的是内存地址，因此修改会直接影响原始变量。在函数内部声明的变量，其作用域是局部的，这有助于防止程序不同部分之间的意外干扰。设计良好的函数应该只做一件事并且把它做好，拥有一个有意义的名称，并避免副作用。递归——即函数调用自身——是出现在高级别试卷中的一个主题，必须使用活动记录栈仔细追踪其执行过程。

10. Debugging and Error Types | 调试与错误类型

Writing correct code on the first attempt is rare; therefore, understanding how to find and fix errors is essential. Errors can be classified into three main categories. Syntax errors occur when the code violates the grammatical rules of the language, such as missing a semicolon or misspelling a keyword. They are detected at compile-time or by the interpreter and prevent the program from running. Runtime errors happen during execution, for example dividing by zero, accessing an array index out of bounds, or trying to open a file that does not exist. These cause the program to crash unless properly handled. Logic errors are the most subtle: the program runs without crashing but produces incorrect results because the algorithm itself is flawed. Debugging techniques include dry-running the code with a trace table, adding temporary output statements to display variable values at key points, and using a debugger tool to step through code line by line. Reading error messages carefully and tracing back from the point of failure to the source of the problem is a skill that separates effective programmers from novices.

一次性写出正确代码的情况很少见；因此，理解如何查找和修正错误至关重要。错误可分为三大类。语法错误发生在代码违反语言语法规则时，例如漏掉分号或拼错关键字。它们在编译时或被解释器检测到，会阻止程序运行。运行时错误发生在程序执行过程中，如除以零、访问越界的数组索引，或试图打开一个不存在的文件。除非得到恰当处理，否则这些错误会导致程序崩溃。逻辑错误最为隐蔽：程序运行无崩溃，却因为算法本身存在缺陷而产生了错误的结果。调试技术包括：使用追踪表进行纸上执行代码、添加临时输出语句以在关键位置显示变量值，以及使用调试工具逐行单步执行代码。仔细阅读错误信息，并从出错点回溯至问题源头，正是区分高效程序员与新手的技能所在。

11. Algorithmic Thinking and Pseudocode | 算法思维与伪代码

Algorithmic thinking is about breaking down a problem into a logical sequence of steps that can be implemented in code. It involves recognising patterns, making decisions about data representation, and evaluating the efficiency of a solution. In IB and CCEA examinations, you will be asked to write, trace, and correct algorithms using a structured pseudocode. This pseudocode is not a real language but a clear, human-readable notation that uses common constructs: variables, assignment, selection, iteration, and subroutines. Key algorithms you should know for the exam include linear search, binary search, bubble sort, and insertion sort. You must be able to describe each algorithm in plain English, illustrate its steps on a given data set, and compare its performance in the best, worst, and average cases. Understanding that not all correct algorithms are equally efficient is vital; the notion of time complexity (Big O notation) is introduced to characterise how the execution time grows with input size, even if a full complexity analysis is not always required at this level. Practice breaking down tasks like validating a password or simulating a vending machine to develop fluent algorithmic expression.

算法思维指的是将一个问题分解成一个可以在代码中实现的逻辑步骤序列。它包括识别模式、就数据表示作出决策，以及评估解决方案的效率。在 IB 和 CCEA 考试中，你会被要求使用结构化伪代码来编写、追踪和修正算法。这种伪代码并非真实的编程语言，而是一种清晰的、人类可读的表示法，使用了常见的结构：变量、赋值、选择、迭代和子程序。你应为考试掌握的关键算法包括线性搜索、二分搜索、冒泡排序和插入排序。你必须能够用简洁的语言描述每种算法，在给定的数据集上展示其步骤，并比较其最佳、最差和平均情况下的性能。理解并非所有正确的算法都具有同等的效率至关重要；时间复杂度（大 O 表示法）的概念正是为了描述执行时间如何随输入规模增长而引入的，即便在这个级别并不总是要求进行完整的复杂度分析。多练习分解诸如验证密码或模拟自动售货机之类的任务，以培养流畅的算法表达能力。

12. Practical Coding Considerations | 编程实践注意事项

Beyond the core constructs, several practical aspects of programming appear regularly in exam questions. Meaningful identifier names, consistent indentation, and appropriate comments are part of writing readable, maintainable code. A good comment explains ‘why’ something is done, not just ‘what’ is being done, since the code itself already shows the ‘what’. When implementing a solution, always consider edge cases: what if the input list is empty? What if the user enters a negative number where only positive is expected? Defensive programming techniques, such as validating inputs and using constants instead of magic numbers, make code more robust. You may also encounter file handling operations: opening a file for reading or writing, reading a line at a time, and closing the file properly. Although the syntax for file I/O varies, the underlying concepts are universal. Finally, be careful with data type conversions: explicitly casting a floating-point number to an integer truncates the decimal part, which might be desired for some applications but can introduce precision errors in calculations. Understanding these nuances will give you an edge in both practical programming tasks and theoretical papers.

除了核心结构外，编程中的一些实践方面也经常出现在考题中。有意义的标识符命名、一致的缩进和恰当的注释是编写可读、可维护代码的一部分。好的注释应解释“为什么”这样做，而不仅仅是“做了什么”，因为代码本身已经展示了“做了什么”。在实现解决方案时，始终要考虑边界条件：如果输入列表为空会怎样？如果用户输入了负数，而期望的只有正数会怎样？防御性编程技术，例如验证输入和使用常量代替“魔数”，能使代码更加健壮。你还可能遇到文件处理操作：打开文件以供读取或写入、一次读取一行，以及正确关闭文件。尽管文件输入/输出的语法各不相同，但其底层概念是通用的。最后，要注意数据类型转换：显式地将浮点数强制转换为整数会截断小数部分，这在某些应用中是期望的行为，但在计算中可能引入精度误差。理解这些细微差别将使你在编程实践任务和理论试卷中占据优势。

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

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