📚 Edexcel A-Level Computer Science: Programming Techniques & Data Structures | 爱德思A-Level计算机科学：编程技巧与数据结构
For Edexcel A-Level Computer Science, programming questions test your ability to design, write, trace, and evaluate code using a range of techniques. This article covers the essential programming constructs, data structures, and algorithms you need to master for Paper 1 and the NEA.
在爱德思 A-Level 计算机科学中，编程题考查你设计、编写、追踪和评估代码的能力，要求掌握多种技巧。本文涵盖你必须掌握的基本编程结构、数据结构与算法，适用于 Paper 1 和非考试评估（NEA）。
1. Programming Paradigms Overview | 编程范式概览
A programming paradigm is a fundamental style of programming. Edexcel expects you to compare procedural, object-oriented, and functional approaches, understanding where each is most appropriate.
编程范式是一种基本的编程风格。爱德思要求你比较过程式、面向对象和函数式方法，并理解各自最适用的场景。
Procedural programming uses step-by-step instructions and subroutines. Object-oriented programming organises code around objects that combine data and behaviour. Functional programming treats computation as the evaluation of mathematical functions and avoids changing state.
过程式编程使用逐步指令和子程序。面向对象编程围绕将数据和行为结合在一起的对象来组织代码。函数式编程将计算视为数学函数的求值，并避免改变状态。
2. Variables, Constants, and Data Types | 变量、常量与数据类型
Variables are named storage locations whose values can change during execution. Constants are fixed values that cannot be changed once assigned, reducing accidental modification.
变量是有名称的存储位置，其值在执行过程中可以改变。常量是一旦赋值就不能改变的固定值，可以减少意外修改。
Common data types include integer, real/float, Boolean, character, and string. Choosing the correct type affects memory usage and the operations that can be performed.
常见数据类型包括整数、实数/浮点数、布尔型、字符和字符串。选择正确的类型会影响内存使用以及可以执行的操作。
- Integer: whole numbers such as 3, -12, 0
- Real/Float: numbers with fractional parts such as 3.14, -0.5
- Boolean: TRUE or FALSE only
- Character: a single symbol such as ‘A’, ‘7’, ‘#’
- String: a sequence of characters such as “TutorHao”
- 整数：如 3、-12、0 这样的整数
- 实数/浮点数：带小数部分的数，如 3.14、-0.5
- 布尔型：只有 TRUE 或 FALSE
- 字符：单个符号，如 ‘A’、’7’、’#’
- 字符串：字符序列，如 “TutorHao”
3. Sequence, Selection, and Iteration | 顺序、选择与迭代
All algorithms can be built from three control structures: sequence, selection, and iteration. Sequence means statements execute one after another in order.
所有算法都可以由三种控制结构构建：顺序、选择和迭代。顺序意味着语句按顺序一条接一条执行。
Selection allows the program to choose between different paths based on a condition. Common forms are IF…THEN…ELSE and CASE/SWITCH statements.
选择允许程序根据条件在不同路径之间进行选择。常见形式是 IF…THEN…ELSE 和 CASE/SWITCH 语句。
Iteration repeats a block of code. Definite iteration uses FOR loops when the number of repetitions is known, while indefinite iteration uses WHILE or REPEAT…UNTIL loops when repetition depends on a condition.
迭代重复一段代码。当重复次数已知时使用 FOR 循环，这是确定迭代；当重复取决于条件时使用 WHILE 或 REPEAT…UNTIL 循环，这是非确定迭代。
4. Subroutines: Procedures and Functions | 子程序：过程与函数
Subroutines are named blocks of code that can be called from elsewhere in a program. They make code modular, reusable, and easier to test.
子程序是有名称的代码块，可以从程序的其他位置调用。它们使代码模块化、可重用且更易于测试。
A procedure performs a task but does not return a value. A function performs a task and returns a value to the calling code.
过程执行任务但不返回值。函数执行任务并向调用代码返回一个值。
Parameters allow data to be passed into subroutines. Passing by value copies the data, while passing by reference passes the memory address so changes affect the original variable.
参数允许将数据传入子程序。按值传递会复制数据，而按引用传递会传递内存地址，因此修改会影响原始变量。
5. Recursion | 递归
Recursion is a technique where a subroutine calls itself to solve a smaller instance of the same problem. Every recursive routine must have a base case to stop the recursion.
递归是一种子程序调用自身来解决同一问题的更小实例的技术。每个递归例程都必须有一个基本情况来停止递归。
A classic example is the factorial function. For n > 0, factorial(n) = n × factorial(n − 1), with factorial(0) = 1 as the base case.
一个经典示例是阶乘函数。当 n > 0 时，factorial(n) = n × factorial(n − 1)，并以 factorial(0) = 1 作为基本情况。
factorial(n) = { 1 if n = 0; n × factorial(n − 1) if n > 0 }
Recursion can be elegant but may use more memory because each call adds a new stack frame. Iterative solutions are often more memory-efficient.
递归可以很优雅，但可能使用更多内存，因为每次调用都会添加一个新的栈帧。迭代解决方案通常更节省内存。
6. Arrays and Records | 数组与记录
An array is a fixed-size, indexed collection of elements of the same data type. Elements are accessed using an index, often starting at 0.
数组是一种固定大小、带索引的同类型元素集合。元素使用索引访问，通常从 0 开始。
For example, an array named scores[5] might store five integer test scores. The third element is accessed as scores[2].
例如，名为 scores[5] 的数组可以存储五个整数测试分数。第三个元素可以通过 scores[2] 访问。
A record is a data structure that groups related fields of possibly different data types. In Python, a dictionary or a class can represent a record.
记录是一种将可能不同数据类型的相关字段组合在一起的数据结构。在 Python 中，字典或类可以表示记录。
| Field | Data Type | Example |
|---|---|---|
| studentID | integer | 2401 |
| name | string | “Ada” |
| grade | character | ‘A’ |
7. Lists, Stacks, and Queues | 列表、栈与队列
A list is a dynamic collection that can grow and shrink. Unlike arrays, lists do not require a fixed size and can hold elements of mixed types in some languages.
列表是一种可以增长和收缩的动态集合。与数组不同，列表不需要固定大小，并且在某些语言中可以存储混合类型的元素。
A stack is a last-in-first-out (LIFO) data structure. The main operations are push (add to top), pop (remove from top), and peek (view top element without removing).
栈是一种后进先出（LIFO）的数据结构。主要操作有 push（压入顶部）、pop（弹出顶部）和 peek（查看顶部元素但不删除）。
A queue is a first-in-first-out (FIFO) data structure. Elements are added at the rear and removed from the front, like a real queue of people.
队列是一种先进先出（FIFO）的数据结构。元素在队尾加入，从队头移除，就像真实中排队的人一样。
8. Searching Algorithms: Linear and Binary Search | 查找算法：线性查找与二分查找
Linear search examines each element one by one until the target is found or the end is reached. It works on unsorted data and has time complexity O(n).
线性查找逐个检查每个元素，直到找到目标或到达末尾。它适用于未排序数据，时间复杂度为 O(n)。
Binary search works only on sorted data. It repeatedly compares the target with the middle element, discarding half the search space each time.
二分查找只适用于已排序数据。它反复将目标与中间元素比较，每次丢弃一半的搜索空间。
Binary search has time complexity O(log n), making it much faster than linear search on large datasets. However, the data must be sorted first.
二分查找的时间复杂度为 O(log n)，在大型数据集上比线性查找快得多。但是，数据必须先排序。
9. Sorting Algorithms: Bubble, Insertion, Merge | 排序算法：冒泡、插入与归并排序
Bubble sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. It has time complexity O(n²) in the worst case.
冒泡排序反复比较相邻元素，如果顺序错误则交换它们。最坏情况下时间复杂度为 O(n²)。
Insertion sort builds the sorted list one item at a time by inserting each new item into its correct position. It is efficient for small or nearly sorted lists.
插入排序通过将每个新项插入到正确位置，一次一项地构建有序列表。它对于小型或接近有序的列表很高效。
Merge sort is a divide-and-conquer algorithm that splits the list in half, sorts each half recursively, and then merges the sorted halves. It has time complexity O(n log n).
归并排序是一种分治算法，将列表分成两半，递归地对每半排序，然后合并有序的两半。其时间复杂度为 O(n log n)。
10. Big-O Notation and Efficiency | 大O表示法与效率
Big-O notation describes how the running time or memory usage of an algorithm grows as the input size n increases. It focuses on the dominant term and ignores constants.
大O表示法描述算法的运行时间或内存使用如何随输入规模 n 增长。它关注主导项并忽略常数。
Common complexities from fastest to slowest include O(1), O(log n), O(n), O(n log n), O(n²), and O(2ⁿ). Constant time is independent of input size.
从最快到最慢的常见复杂度包括 O(1)、O(log n)、O(n)、O(n log n)、O(n²) 和 O(2ⁿ)。常数时间与输入规模无关。
For example, accessing an array element by index is O(1), while a nested loop over an n×n grid is O(n²). Choosing efficient algorithms matters for large data.
例如，通过索引访问数组元素是 O(1)，而对 n×n 网格使用嵌套循环是 O(n²)。对于大数据，选择高效算法非常重要。
11. Object-Oriented Programming Concepts | 面向对象编程概念
Object-oriented programming (OOP) models real-world entities as objects. A class is a blueprint, and an object is an instance of that class.
面向对象编程（OOP）将现实世界实体建模为对象。类是一个蓝图，对象是该类的一个实例。
Encapsulation bundles data (attributes) and methods that operate on that data into a single unit. It protects data by making attributes private and providing public getter and setter methods.
封装将数据（属性）与操作这些数据的方法绑定到一个单元中。它通过将属性设为私有并提供公共 getter 和 setter 方法来保护数据。
Inheritance allows a new class to derive properties and methods from an existing class. Polymorphism lets objects of different classes respond to the same method call in their own way.
继承允许新类从现有类派生属性和方法。多态让不同类的对象以各自的方式响应同一个方法调用。
12. Defensive Design and Testing | 防御式设计与测试
Defensive design anticipates misuse and errors. Techniques include input validation, range checks, length checks, format checks, and presence checks.
防御式设计预见到误用和错误。相关技术包括输入验证、范围检查、长度检查、格式检查和存在性检查。
Testing should use normal data, boundary data, invalid data, and erroneous data. Boundary testing is especially important because many errors occur at the edges of valid ranges.
测试应使用正常数据、边界数据、无效数据和错误数据。边界测试尤其重要，因为许多错误发生在有效范围边缘。
Trace tables are used to track variable values line by line when checking an algorithm. They help identify logic errors in loops and conditionals.
跟踪表用于在检查算法时逐行跟踪变量值。它们有助于发现循环和条件中的逻辑错误。
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课程辅导，国外大学本科硕士研究生博士课程论文辅导