📚 Common Misconceptions and Corrections in Year 13 WJEC Computer Science | Year 13 WJEC 计算机常见误区与纠正方法
Year 13 WJEC Computer Science covers a wide range of advanced topics, from data structures and algorithms to networking, databases, and object-oriented programming. Many students develop subtle misunderstandings that can cost marks in exams and practical assessments. This article highlights the most common misconceptions and provides clear corrections for each, helping you refine your knowledge.
Year 13 WJEC 计算机科学涵盖了从数据结构与算法到网络、数据库以及面向对象编程的众多高阶主题。许多学生会形成一些细微的误解，这些误解可能在考试和实践评估中失分。本文重点指出最常见的误区，并为每个误区提供清晰的纠正方法，帮助你完善知识体系。
1. Confusing Logical and Bitwise Operators | 混淆逻辑运算符与按位运算符
Many students use logical operators (&&, ||, !) where bitwise operators (&, |, ~) are required, or treat them as interchangeable. This is particularly common when dealing with multiple conditions packed into a single integer flag variable.
许多学生在需要使用按位运算符 (&, |, ~) 的地方使用了逻辑运算符 (&&, ||, !)，或认为两者可以互换。这在处理压缩到单个整数标志变量中的多个条件时尤其常见。
A typical mistake is writing if (num && 1) to test the least significant bit. Logical AND returns true if both operands are truthy, so this expression evaluates to true for any non‑zero number, regardless of the bit pattern. The correct test uses bitwise AND: if (num & 1).
一个典型错误是用 if (num && 1) 测试最低有效位。逻辑与在两个操作数都为真值时返回 true，因此对于任何非零数字该表达式都为真，而无论位模式如何。正确的测试应使用按位与：if (num & 1)。
Another error arises when combining bitmasks. Writing flags & MASK == MASK without parentheses evaluates as flags & (MASK == MASK), which is always 1 due to operator precedence. The correction is (flags & MASK) == MASK.
另一个错误出现在组合位掩码时。不加括号地书写 flags & MASK == MASK 会被解释为 flags & (MASK == MASK)，由于运算符优先级关系，该式结果始终为 1。纠正方法是 (flags & MASK) == MASK。
Remember: logical operators work with truth values, bitwise operators work with individual bits. Always parenthesise bitwise expressions when mixing with comparison operators.
请记住：逻辑运算符处理真值，按位运算符处理单个比特位。当与比较运算符混合使用时，始终将按位表达式用括号括起。
2. Surface-Level Understanding of Recursion | 对递归仅停留在表面理解
Many Year 13 students can trace a simple recursive function but cannot design one from scratch. They often confuse the base case with the infinite loop condition and fail to recognise how the call stack unwinds.
许多 Year 13 学生能够跟踪一个简单的递归函数，却无法从头设计一个。他们常常混淆基准条件与无限循环条件，并且未能理解调用栈的回退机制。
The classic factorial example is memorised: n! = n × (n-1)! with base case 0! rge sort, students struggle because they have not internalised the recursive leap of faith – trusting that the smaller subproblem will be solved correctly.
阶乘的经典例子被记住了：n! = n × (n-1)!，基准情况为 0! = 1。然而，当要求编写树遍历或归并排序的递归解法时，学生就会感到困难，因为他们没有内化“递归的信任之跃”——相信更小的子问题会被正确解决。
Correction: practice designing recursive solutions by first identifying the simplest input that can be solved directly (base case), then expressing the solution for a larger input in terms of a smaller one. Visualising the call stack with diagrams for binary search or Fibonacci helps solidify the concept.
纠正：通过首先确定可以直接解决的最简单输入（基准情况），然后用较小的输入表示较大输入的解，来练习设计递归解法。对于二分搜索或斐波那契数列，借助图示可视化调用栈有助于巩固这一概念。
3. Assuming Linked Lists Support Random Access | 误以为链表可以随机访问
After learning that arrays allow O(1) random access, students often unconsciously extend this property to linked lists. They imagine that list[3] is a cheap operation in a singly linked list as well.
在学习数组支持 O(1) 随机访问后，学生们常常无意识地将这一特性延伸至链表。他们以为 list[3] 在单链表中也是一种低代价操作。
In a linked list, every element stores a reference to the next node. To reach the k‑th element, you must follow k references from the head, giving O(n) time complexity. Treating a linked list like an array leads to inefficient algorithms, especially in exam‑style tracing questions where you are asked to count comparisons.
在链表中，每个元素存储指向下一节点的引用。要到达第 k 个元素，必须从头沿引用遍历 k 次，时间复杂度为 O(n)。把链表当作数组会导致低效的算法，尤其是在考试风格的追踪题中，当要求你统计比较次数时更是如此。
Correction: always be explicit about the data structure’s access characteristics. Use arrays or arrays lists when indices are needed frequently; prefer linked lists for operations at the front or when memory allocation is unpredictable. When revising, sketch the node‑pointer diagram and walk through an access operation step by step.
纠正：始终明确数据结构的特点。当频繁使用索引时，用数组或数组列表；在操作集中于前端或内存分配不可预测时，优先选择链表。复习时，画出节点‑指针图并一步步模拟一次访问操作。
4. Mixing Up Primary Key and Foreign Key Roles | 混淆主键和外键的作用
Students often memorise that a primary key uniquely identifies a record and a foreign key links tables, but they fail to apply these ideas when designing a relational schema. A common mistake is placing the foreign key in the wrong table.
学生们通常记住了主键唯一标识一条记录、外键连接表，但在设计关系模式时却无法应用这些概念。一个常见错误是将外键放在错误的表中。
Consider a one‑to‑many relationship between Customer and Order. The foreign key must reside in the Order table to reference the CustomerID primary key. Placing the foreign key in the Customer table would incorrectly suggest a customer can have only one order.
考虑 Customer 与 Order 之间的一对多关系。外键必须驻留在 Order 表中，以引用 CustomerID 主键。若将外键放在 Customer 表中，则会错误地暗示一个客户只能有一个订单。
Correction: model the relationship first, identify the 'many' side, and place the foreign key there. Practice entity‑relationship diagrams and always check cardinality. In exam questions, trace a join to verify that the foreign key points back to a valid primary key value.
纠正：首先建立关系模型，识别“多”的一方，并将外键放在那里。多练习实体‑关系图，并始终检查基数。在考试题目中，通过追踪一次连接来验证外键是否指向有效的主键值。
5. Believing TCP and UDP Differ Only in Speed | 认为 TCP 与 UDP 仅有速度区别
A superficial summary of the transport layer often reduces TCP to 'reliable but slow' and UDP to 'fast but unreliable'. This creates the misconception that speed is the primary deciding factor.
对传输层的肤浅总结常将 TCP 归为“可靠但慢”，UDP 归为“快但不可靠”。这造成了一个误解，即速度是主要决定因素。
TCP provides ordered, error‑checked delivery using a three‑way handshake, acknowledgements, and retransmissions. UDP is a connectionless protocol with no guarantee of delivery or order. The choice depends on application needs: streaming video can tolerate packet loss (UDP) while file transfer requires zero corruption (TCP).
TCP 通过三次握手、确认和重传机制提供有序且经校验的交付。UDP 是一种无连接协议，不保证交付或顺序。选择取决于应用需求：视频流可以容忍丢包（用 UDP），而文件传输要求零损坏（用 TCP）。
Correction: study the header fields and lifecycle of each protocol. Be able to explain how TCP achieves reliability through sequence numbers and sliding windows. Remember that UDP’s simplicity is what makes it suitable for DNS and real‑time voice, not just raw speed.
纠正：研究每种协议的头部字段和生命周期。能够解释 TCP 如何通过序列号和滑动窗口实现可靠性。记住，UDP 的简洁性使其适用于 DNS 和实时语音，而不仅仅是原始速度快。
6. Misinterpreting Big O Notation | 误解大 O 记号
Students often memorise a table of time complexities without understanding what Big O actually measures. They confuse O(n) meaning “for n elements it runs in n time” with an absolute timing or machine cycle count.
学生们常常记忆时间复杂度表，却不理解大 O 记号实际衡量什么。他们将 O(n) 的含义 “对于 n 个元素，运行 n 时间” 与绝对时间或机器周期数混淆。
Big O describes an upper bound on the growth rate of an algorithm’s resource usage as input size increases. Constants are ignored. An O(n) algorithm may take 5n + 200 steps; a slower O(log n) algorithm can outperform it for small n but will ultimately scale better. Students also believe that nested loops always mean O(n²), ignoring cases where inner loop iterations are not proportional to n, such as while loops that halve the range.
大 O 记号描述了随着输入规模增大，算法资源用量的增长率上界。常数被忽略。一个 O(n) 算法可能执行 5n + 200 步；一个较慢的 O(log n) 算法在 n 较小时可能表现欠佳，但最终扩展性更好。学生还常常认为嵌套循环必定意味着 O(n²)，却忽略了内层循环迭代不与 n 成正比的情况，例如将范围减半的 while 循环。
Correction: derive Big O by counting the dominant term in operations relative to n. Practise with code snippets that mix loops, recursion, and library calls. Use precise language: “worst‑case time complexity” rather than just “speed”.
纠正：通过计算相对于 n 的操作中主导项来推导大 O 记号。多练习包含循环、递归和库调用的代码片段。使用准确的语言：“最坏情况时间复杂度”，而非笼统的“速度”。
7. Underestimating Testing in the Software Development Lifecycle | 在软件开发生命周期中低估测试
When sketching the waterfall or agile model, many students sketch a single box labelled “Testing” after implementation. They assume testing is a one‑off phase and fail to integrate it across the lifecycle.
在绘制瀑布或敏捷模型时，许多学生会在实现之后画一个标有“测试”的单一方框。他们认为测试是一次性的阶段，未能将其整合到整个生命周期中。
In reality, testing occurs at multiple levels: unit testing during coding, integration testing as components are combined, system testing against requirements, and acceptance testing with the end user. In agile models, testing is continuous with each iteration.
事实上，测试发生在多个层面：编码阶段的单元测试、组件组合时的集成测试、针对需求的系统测试，以及面向最终用户的验收测试。在敏捷模型中，测试随每次迭代而持续进行。
Correction: learn the specific test types and when they apply. Understand the difference between validation (did we build the right product?) and verification (did we build it correctly?). Use real‑world scenarios to link each test type to a life‑cycle stage.
纠正：学习具体的测试类型及其适用时机。理解确认（我们是否构建了正确的产品？）与验证（我们是否正确地构建了产品？）之间的区别。使用真实场景将每种测试类型与生命周期阶段联系起来。
8. Confusing Inheritance with Composition (OOP) | 混淆面向对象中的继承与组合
A common object‑oriented fallacy is that inheritance should always be used to reuse code. This leads to deep, rigid class hierarchies that break encapsulation and make future changes difficult.
一个常见的面向对象谬误是：复用代码就应始终使用继承。这导致产生深而僵化的类层次结构，破坏封装性并使后续修改变得困难。
Inheritance models an “is‑a” relationship (a Car is‑a Vehicle). Composition models a “has‑a” relationship (a Car has‑an Engine). Overusing inheritance for code reuse can cause a fragile base class problem when base class changes ripple through all subclasses.
继承建模“是一个”的关系（汽车是一个交通工具）。组合建模“有一个”的关系（汽车有一个引擎）。为复用代码而过度使用继承可能会引发脆弱的基类问题，当基类的更改波及所有子类时尤为严重。
Correction: favour composition over inheritance unless a true subclass relationship exists. Use interfaces to define contracts rather than relying solely on abstract classes. When designing, ask: “Does B need to be substitutable for A?” If not, composition is likely better.
纠正：除非存在真正的子类关系，否则优先采用组合而非继承。使用接口定义契约，而非仅依赖抽象类。设计时，问自己：“B 需要能够替换 A 吗？” 如果不需要，组合很可能更优。
9. Assuming Binary Search Trees Are Always Balanced | 以为二叉搜索树总是平衡的
After learning that binary search on an array runs in O(log n), students often assume the same efficiency for any Binary Search Tree (BST). They forget that a BST built from sorted insertions degenerates into a linked list.
在学习数组的二分搜索为 O(log n) 之后，学生通常以为任何二叉搜索树（BST）都具有相同的效率。他们忘记了由按序插入构建的 BST 会退化为一个链表。
A worst‑case BST has all nodes along one branch, giving O(n) search. The average height of a randomly built BST is O(log n), but exam questions frequently test the worst‑case behaviour. Students need to recognise that balancing algorithms like AVL rotations are required to guarantee logarithmic height.
最坏情况下的 BST 所有节点沿一条分支分布，导致搜索为 O(n)。随机构建的 BST 平均高度为 O(log n)，但考试题常考最坏情况行为。学生需认识到，需使用 AVL 旋转等平衡算法才能保证对数高度。
Correction: manually construct a BST from a sorted list and observe the shape. Draw an AVL tree for the same data and see how rotations restructure it. Remember the key phrase: “The height of a BST ranges from O(log n) to O(n) depending on insertion order.”
纠正：从有序列表手动构建一个 BST 并观察其形状。对相同数据绘制一棵 AVL 树，观察旋转如何重构它。记住关键的一句话：“BST 的高度从 O(log n) 到 O(n) 不等，取决于插入顺序。”
10. Confusing Abstract Data Type (ADT) with Implementation | 混淆抽象数据类型及其实现
Students often treat “stack” as synonymous with “array” or “linked list”. An ADT defines what operations are available and their behaviour, not how they are implemented internally.
学生常将“栈”视作“数组”或“链表”的同义词。抽象数据类型（ADT）定义了可用的操作及其行为，而非内部如何实现。
For instance, a stack ADT supports push, pop, and peek. It could be implemented using an array (with a top index) or a linked list (with a head pointer). In the exam, describing a stack as “an array” loses marks because you have confused the contract with the mechanism.
例如，栈 ADT 支持 push、pop 和 peek 操作。它可以使用数组（带 top 索引）实现，也可以使用链表（带头指针）实现。在考试中，若将栈描述为“一个数组”，就会失分，因为你混淆了契约与机制。
Correction: when defining any ADT (list, queue, tree), first list the essential operations without mentioning the underlying structure. Only then discuss possible implementations and their trade‑offs. Use the phrase “an array‑based implementation of a stack”, not “an array stack”.
纠正：定义任何 ADT（列表、队列、树）时，先列出必要操作而不提及底层结构。然后再讨论可能的实现及其权衡。使用“基于数组的栈实现”这一表述，而非“数组栈”。
11. Overlooking the Role of the Operating System in Resource Management | 忽视操作系统在资源管理中的作用
When asked about scheduling or memory paging, many students describe the algorithms in isolation, forgetting to link them to the OS kernel. They treat the OS as a static library rather than an active manager.
当被问及调度或内存分页时，许多学生孤立地描述算法，忘记将其与操作系统内核联系起来。他们将操作系统视为一个静态库，而非主动的管理者。
The OS is responsible for allocating CPU time slices, managing virtual memory, handling interrupts, and enforcing protection. A round‑robin scheduling answer must mention the scheduler, context switching, and priority queues; a paging answer needs to refer to the Memory Management Unit (MMU) and page tables.
操作系统负责分配 CPU 时间片、管理虚拟内存、处理中断并执行保护。轮转调度回答须提及调度器、上下文切换和优先级队列；分页回答须涉及内存管理单元（MMU）和页表。
Correction: always place algorithms in the context of the OS’s resource management functions. Use exam‑style command words like “explain how the operating system…” to frame your answer. Revise the roles of the kernel: process management, memory management, file systems, and I/O.
纠正：始终将算法置于操作系统资源管理功能的上下文中。使用考试风格的指令词，如“解释操作系统如何……”来组织答案。复习内核的角色：进程管理、内存管理、文件系统和 I/O。
12. Ignoring Data Integrity and Referential Integrity in Database Transactions | 在数据库事务中忽视数据完整性与参照完整性
Students perceive transactions as simply a way to group SQL statements. They overlook the ACID properties (Atomicity, Consistency, Isolation, Durability) and the need to enforce referential integrity with foreign key constraints.
学生将事务简单视为一组 SQL 语句的集合。他们忽视了 ACID 特性（原子性、一致性、隔离性、持久性），以及使用外键约束强制参照完整性的必要性。
When updating a foreign key, the DBMS checks that the new value exists in the referenced table. Without ON DELETE CASCADE or similar rules, deleting a primary key record would violate referential integrity. A transaction must be rolled back if any part fails, preserving atomicity.
当更新外键时，数据库管理系统会检查新值在被引用的表中是否存在。若没有 ON DELETE CASCADE 或类似规则，删除主键记录将违反参照完整性。若任一部分失败，事务必须回滚，以保持原子性。
Correction: practice writing SQL that includes FOREIGN KEY ... REFERENCES and ON DELETE/UPDATE clauses. Describe how the DBMS ensures consistency through constraint checks at the end of a transaction. Link ACID to real‑world scenarios like bank transfers.
纠正：练习编写包含 FOREIGN KEY ... REFERENCES 及 ON DELETE/UPDATE 子句的 SQL。描述数据库管理系统如何在事务结束时通过约束检查来确保一致性。将 ACID 与银行转账等真实场景联系起来。
Published by TutorHao | Computer Science Revision Series | aleveler.com
更多咨询请联系16621398022（同微信）
或截图后用「扫一扫 → 相册」选择本图