📚 Year 13 OCR Computer Science: Common Misconceptions and Corrections | Year 13 OCR 计算机：常见误区与纠正方法
Over the two years of OCR A‑Level Computer Science, students build a rich understanding of both theoretical concepts and practical programming. However, as the material becomes more abstract – from Boolean algebra to Turing machines, from Dijkstra to databases – certain misunderstandings become stubbornly persistent. These misconceptions can easily cost marks in the exam, not because the student lacks effort, but because the underlying mental model is slightly skewed. This article pinpoints the most common errors seen across Year 13 topics and provides clear corrections, helping you replace fragile knowledge with robust, exam‑ready understanding.
在 OCR A‑Level 计算机科学两年的学习中，学生对理论概念和编程实践的理解不断加深。然而，随着内容变得越来越抽象——从布尔代数到图灵机、从 Dijkstra 算法到数据库——某些误解顽固地留存了下来。这些误区在考试中往往白白丢分，原因不是努力不够，而是底层的心智模型稍有偏斜。本文直击 Year 13 各个主题中最常见的错误，并给出清晰的纠正，帮助你用扎实、适合考试的理解取代脆弱的知识。
1. Recursion is Always Inefficient and Should Be Avoided | 递归总是低效的，应当尽量避免
Many students believe that recursion is inherently slower and more memory‑hungry than iteration, so it should never be used. This is a half‑truth that misses the point. For problems with a naturally self‑similar structure – such as tree traversals or divide‑and‑conquer algorithms – a well‑written recursive solution can be just as efficient as its iterative counterpart, and vastly simpler to reason about. The overhead comes from repeated function calls and, in languages that do not optimise tail recursion, deep call stacks. However, tail‑recursive functions (where the recursive call is the final operation) can be optimised by the compiler to reuse the same stack frame, effectively turning recursion into iteration under the hood. In the OCR exam, you are expected to trace both recursive and iterative algorithms, and to recognise that the choice depends on the problem domain, not a blanket rule of "recursion is bad".
很多学生认为递归本质上比迭代更慢、更吃内存，因此绝不应该使用。这是一种半真半假的误解。对于天然具有自相似结构的问题——例如树的遍历或分治算法——编写得当的递归解法可以和迭代版本同样高效，并且简洁得多。递归的开销来自重复的函数调用，以及在不支持尾递归优化的语言中可能出现的深层调用栈。但尾递归函数（递归调用是函数的最后一步操作）可以被编译器优化，重用同一个栈帧，从而在底层将递归转化为迭代。在 OCR 考试中，你既要会跟踪递归算法，也要能跟踪迭代算法，并且明白选择哪种方式取决于问题领域，而非一条“递归不好”的死规矩。
2. All Binary Trees Are Binary Search Trees | 所有二叉树都是二叉搜索树
It is surprisingly common to see students treat every binary tree as a binary search tree (BST) and apply BST‑specific rules to ordinary trees. A binary tree is simply a tree in which each node has at most two children; a BST imposes a strict ordering property: for any node, all values in its left subtree are less than the node’s value, and all values in its right subtree are greater (or equal, depending on convention). This means that inorder traversal of a BST yields a sorted sequence, but inorder traversal of an arbitrary binary tree does not. The misconception often surfaces in questions about tree insertion, deletion, or traversal outputs. Always check whether the question explicitly states "binary search tree" before applying any ordering assumptions.
出乎意料地，很多学生经常把每一棵二叉树都当作二叉搜索树，并对普通树套用 BST 特有的规则。二叉树只是每个节点最多有两个孩子的树；而二叉搜索树强加了一条严格的排序性质：对于任意节点，其左子树中所有值都小于该节点的值，右子树中所有值都大于（或等于，视惯例而定）。这意味着二叉搜索树的中序遍历会得到有序序列，但任意二叉树的中序遍历不会。这种误解经常出现在关于树的插入、删除或遍历输出的题目中。在应用任何排序假设之前，务必先确认题目是否明确注明“二叉搜索树”。
2. Stacks and Queues Are Interchangeable in Problem Solving | 栈和队列在解题中可以互换
Stacks (LIFO – Last In, First Out) and queues (FIFO – First In, First Out) are often mistaken for two slight variations of the same thing, leading students to use them interchangeably in algorithm design. In reality, their behavioural difference is fundamental. A depth‑first search uses a stack (explicitly or via recursion), while a breadth‑first search requires a queue. Using the wrong abstract data type will change the order of processing and produce incorrect results, even if the rest of the algorithm is correct. In the exam, you may be asked to simulate an algorithm that uses a stack or a queue; treat the underlying data structure as a strict contract: items are added only at one end (put/push) and removed only from the prescribed end (pop/dequeue).
栈（LIFO，后进先出）和队列（FIFO，先进先出）往往被误认为是同一概念的两种细微变体，导致学生在算法设计时随意互换。实际上，二者的行为差异是本质性的。深度优先搜索使用栈（显式地或通过递归），而广度优先搜索必须使用队列。用错了抽象数据类型将改变处理顺序并产生错误结果，即便算法其余部分完全正确。在考试中，你可能会被要求模拟一个使用栈或队列的算法；请将底层数据结构视为严格的契约：元素只能在一端添加（入栈/入队），也只能从规定的一端移除（出栈/出队）。
3. Dijkstra's Algorithm Works with Negative Edge Weights | Dijkstra 算法可处理负权边
Many students recall that Dijkstra’s algorithm finds the shortest path in a weighted graph and assume it works for all weights, including negatives. This is a critical mistake. Dijkstra relies on the "greedy" principle that once a node’s shortest distance is finalised, it will never need to be updated. With negative edge weights, a longer path initially avoided might later become cheaper after adding a negative edge, violating the assumption. The algorithm will therefore produce incorrect results on graphs containing negative cycles or even a single negative edge in some configurations. The OCR specification expects you to know this limitation. For graphs with negative edges, the Bellman‑Ford algorithm should be mentioned as an alternative, though its detailed mechanics are not always examined.
许多学生记得 Dijkstra 算法用于求加权图的最短路径，于是便认为它适用于所有权重，包括负值。这是一个致命错误。Dijkstra 算法的核心是“贪心”原则：一旦某个节点的最短距离被确定，就不再需要更新。但若存在负权边，一开始避开的较长路径在累加负权后可能反而变得更短，这就违背了上述假设。因此，算法会在包含负环甚至仅在某些配置下包含单条负边的图上给出错误结果。OCR 大纲要求你知晓这一限制。对于含有负权边的图，可以提到 Bellman‑Ford 算法作为替代，不过其详细机制不一定会直接考查。
4. De Morgan's Laws Are Simply About Swapping ANDs and ORs | 德摩根定律仅仅是交换 AND 与 OR
A shallow understanding of De Morgan’s laws leads students to write ¬(A ∧ B) = ¬A ∧ ¬B – swapping the operator but forgetting to swap the negation. The correct form is of course ¬(A ∧ B) = ¬A ∨ ¬B and ¬(A ∨ B) = ¬A ∧ ¬B. Exam questions frequently test this by presenting a logic circuit or Boolean expression and asking for a simplified equivalent. The misconception often becomes apparent when students break the bar over a compound expression without changing the underlying operation. Semantic errors like these propagate through Karnaugh map simplifications and circuit design. Practise expanding the law both ways: when applying negation to a whole bracket, flip both the operator and all literals inside.
对德摩根定律的肤浅理解会导致学生写出 ¬(A ∧ B) = ¬A ∧ ¬B 这样的错误——交换了运算符，却忘了同时翻转否定。正确形式当然是 ¬(A ∧ B) = ¬A ∨ ¬B 以及 ¬(A ∨ B) = ¬A ∧ ¬B。考试中常见这样的题目：给出一个逻辑电路或布尔表达式，要求写出其简化等价形式。当学生在拆去“长非号”时没有改变内部的逻辑运算，这种误解就暴露无遗。此类语义错误会延伸到卡诺图化简和电路设计中。建议反复练习双向应用：对整个括号取反时，既要翻转运算符，也要将所有文字取反。
5. Everything Must Be Normalised to 3NF to Be 'Correct' | 所有表都必须规范化到 3NF 才算“正确”
Database normalisation is often taught as a step‑by‑step process towards an ideal Third Normal Form (3NF), and students readily assume that any table not in 3NF is somehow wrong. While normalisation reduces update anomalies, denormalisation is a deliberate practice in real‑world systems to improve read performance at the cost of some redundancy. The OCR specification expects you to evaluate trade‑offs: a fully normalised database may require many JOIN operations that slow down queries. The important skill is to identify partial and transitive dependencies and to be able to normalise a given dataset to 1NF, 2NF, and 3NF, rather than declaring any non‑3NF design as invalid. Always read the scenario: sometimes a degree of redundancy is justified for performance reasons.
数据库规范化经常被当作一个逐步达到理想第三范式（3NF）的过程来教授，学生很容易就认为任何不满足 3NF 的表都是错误的。虽然规范化可以减少更新异常，但在真实系统中，为了提高读取性能，设计者会刻意进行反规范化，牺牲一定的冗余。OCR 大纲要求你评估这些权衡：一个完全规范化的数据库可能需要大量 JOIN 操作，从而拖慢查询。关键技能是要能够识别部分依赖和传递依赖，并能够将给定数据集规范化为 1NF、2NF 和 3NF，而不是武断地认为任何非 3NF 的设计都不合理。务必阅读题目场景：有时出于性能考虑，适度的冗余是合理的。
6. Inheritance Means Copying All Code from the Parent Class | 继承就是原封不动地复制父类所有代码
In object‑oriented programming, some students treat inheritance as a simple code‑copying mechanism. They mistakenly believe that a subclass automatically receives an identical copy of every method and attribute, with no ability to change or override them. This leads to confusion about the keyword extends and the concept of polymorphism. In reality, inheritance establishes an "is‑a" relationship and allows the subclass to reuse, override, or extend the behaviour of the superclass. Method overriding is a deliberate feature: a subclass can provide its own implementation of a method while retaining the same signature, enabling dynamic dispatch. The OCR pseudocode and Python‑based questions may ask you to trace code involving superclasses and subclasses; you must understand that calls to an overridden method on a subclass object will execute the subclass version, not the superclass version.
在面向对象编程中，一些学生把继承当作简单的代码复制机制。他们错误地认为子类会自动获得与父类完全相同的所有方法和属性的副本，既不能修改，也不能覆写。这导致对 extends 关键字和多态概念的理解混乱。实际上，继承建立了一种“是一个”的关系，允许子类复用、覆写或扩展父类的行为。方法覆写是一项刻意设计的功能：子类可以用相同的签名提供自己的方法实现，从而支持动态分派。OCR 伪代码以及基于 Python 的题目可能要求你跟踪涉及超类和子类的代码；你必须明白，对子类对象调用已覆写的方法时，实际执行的是子类版本，而非超类版本。
7. Finite State Machines Can Model Any Computational Problem | 有限状态机可以建模任何计算问题
After learning about Finite State Machines (FSMs) and their use in lexical analysis and simple control units, students sometimes overgeneralise their power. An FSM without external memory can only recognise regular languages; it cannot solve problems that require counting arbitrary numbers of matches or managing nested structures – for instance, checking balanced parentheses. The Chomsky hierarchy places regular languages strictly below context‑free and recursively enumerable languages. A Turing machine, with its infinite tape, is the model that can perform any computation a modern computer can. In the exam, you may need to distinguish between what an FSM can do (e.g., validate a digit sequence with a fixed pattern) and what requires a Turing machine (e.g., simulate the execution of any algorithm). Confusing the two leads to flawed modelling decisions.
在学习有限状态机及其在词法分析和简单控制单元中的应用之后，学生有时会高估它的能力。没有外部存储的 FSM 只能识别正则语言；它无法解决需要计数字符数量或处理嵌套结构的问题——例如检验括号匹配。在乔姆斯基层级中，正则语言严格位于上下文无关语言和递归可枚举语言之下。拥有无限带的图灵机才是能够执行现代计算机所能执行的任何计算的模型。在考试中，你可能需要区分 FSM 能做什么（比如校验具有固定模式的数字序列）和什么需要图灵机（比如模拟任意算法的执行）。混淆二者会导致错误的建模决策。
8. More Pipeline Stages Always Improve CPU Performance | 增加流水线级数总能提升 CPU 性能
Pipelining improves instruction throughput by splitting the execution cycle into multiple stages, but a popular oversimplification is that "more stages means more speed". While deeper pipelines can increase the clock rate because each stage does less work, they also exacerbate the penalties from pipeline hazards – data hazards, control hazards (branches), and structural hazards. The branch misprediction penalty grows with pipeline depth, and forwarding circuits become more complex. At some point, diminishing returns set in, and further deepening can lead to performance degradation if the code suffers from frequent stalls. The OCR course covers RISC pipelines and the associated hazards; you are expected to explain why modern processor designers balance stage count against branch prediction accuracy and hazard resolution efficiency.
流水线技术通过将执行周期划分为多个阶段来提高指令吞吐率，但一个常见的过度简化的说法是“级数越多速度越快”。更深的流水线确实可能因为每级所做工作更少而提高时钟频率，但它们也会加剧流水线冒险带来的惩罚——包括数据冒险、控制冒险（分支）以及结构冒险。分支预测错误的代价随流水线深度增加而增大，而前递电路也变得更为复杂。到一定程度就会出现边际效益递减，如果代码遭遇频繁的停顿，进一步加深流水线甚至会导致性能下降。OCR 课程涉及 RISC 流水线及相关冒险；你要能够解释为什么现代处理器设计者需要在流水线级数与分支预测准确度及冒险解决效率之间取得平衡。
9. TCP Provides a Guaranteed Delivery Because It Is 'Reliable' | TCP 因为“可靠”所以能保证交付
TCP is described as a reliable transport‑layer protocol, which leads some students to believe it guarantees data delivery under all circumstances. In truth, TCP provides reliability by means of acknowledgements, timeouts, and retransmissions. If a packet is lost and the retransmission limit is reached, the connection will be aborted and the data will not be delivered. What TCP guarantees is that, within the lifetime of a connection, data will either be delivered correctly and in order, or the sender will be informed of a failure. It does not create a magical guarantee that every piece of data will always reach its destination regardless of network conditions. Understanding this nuance is important when discussing the limits of fault tolerance in networked systems.
TCP 被描述为一种可靠的传输层协议，这使得一些学生认为它在任何情况下都能保证数据交付。实际上，TCP 通过确认、超时和重传机制来提供可靠性。如果某个数据包丢失并且重传次数达到上限，连接将会中止，数据不会被交付。TCP 真正保证的是：在一个连接的生命周期内，数据要么被正确且按序地交付，要么发送方收到失败通知。它并不创造一条无论网络状况如何，每一份数据都必定抵达目的地的魔法承诺。理解这一细微差别，对于讨论网络系统中容错的界限很重要。
9. Floating‑Point Numbers Can Represent All Real Numbers Exactly | 浮点数能精确表示所有实数
When studying floating‑point representation (mantissa and exponent), students often forget that it is a finite, discrete system. Some real numbers, such as 0.1 (1/10), have no exact representation in binary floating point because they require an infinite repeating fraction. This leads to rounding errors that accumulate in calculations, causing unexpected behaviour like 0.1 + 0.2 ≠ 0.3 in many programming languages. The OCR specification expects you to explain the limitations of binary floating point, calculate absolute and relative errors, and normalise floating‑point numbers. Always remember: a floating‑point number represents a small, finite set of rational numbers; precision is limited by the number of bits in the mantissa, and the gap between representable values increases as the magnitude grows.
在学习浮点数表示（尾数和指数）时，学生经常忘记这是一个有限且离散的系统。某些实数，例如 0.1 (1/10)，在二进制浮点数中没有精确表示，因为它们会呈现无限循环小数。这会导致舍入误差在计算中不断累积，从而带来诸如 0.1 + 0.2 ≠ 0.3 的意外行为（这在许多编程语言中都会出现）。OCR 大纲要求你能够解释二进制浮点数的局限，计算绝对误差与相对误差，并对浮点数进行规范化。务必牢记：浮点数仅表示一小部分、有限的有理数；精度受限于尾数的位数，且可表示值之间的间距会随着数值增长而变大。
Published by TutorHao | Computer Science Revision Series | aleveler.com
更多咨询请联系16621398022（同微信）
或截图后用「扫一扫 → 相册」选择本图