教程建议 35 分钟学习等级 5/8

PYTHON LESSON 070

小火车挂车厢

理解链表的结构与优势,用类实现节点和单链表的挂接、遍历与删除。

00 · 学习目标

这一课要解决什么?

先想一想列表中间插一个元素要挪动后面所有元素,有没有“挂上去就走”的结构?
完成任务小火车调度系统
学习顺序定义 → 语法 → 最小实例 → 独立练习

学完后,你应该能够

  • class Node:数据 + next 指针
  • while cur is not None: 顺链遍历
  • cur.next = cur.next.next 跳过一节车厢

01 · 核心概念

链表:用类串起来的车厢(单链表)

链表:用类串起来的车厢(单链表):列表的元素在内存里排排坐,中间插一个,后面全体挪窝。链表换了思路:每节车厢(节点)自带一个挂钩(next),指向下一节——拆装车厢只需改挂钩,谁也不用挪。

考级对应GESP Python 5 级 · 链表
学习边界

课程使用普通类解释对象模型;dataclass、property、抽象基类和元类是后续工程工具。

02 · 语法与规则

先记住这 3 条,再开始写程序

01class Node:数据 + next 指针

先准确读出这条写法的结构与作用。

02while cur is not None: 顺链遍历

换一组最小数据,手工推演一次结果。

03cur.next = cur.next.next 跳过一节车厢

再用边界值或反例确认它的适用条件。

03 · 完整实例

代码、运行结果和解释放在一起看

train-linked-list.pyPYTHON 3.12
# 小火车挂车厢:用类实现单链表
class Car:
    """一节车厢:装着车厢号,挂着下一节车厢"""
    def __init__(self, no):
        self.no = no
        self.next = None

class Train:
    """一列小火车:head 指向第一节车厢"""
    def __init__(self):
        self.head = None

    def add_tail(self, no):
        """在车尾挂一节车厢"""
        new_car = Car(no)
        if self.head is None:
            self.head = new_car
            return
        cur = self.head
        while cur.next is not None:
            cur = cur.next
        cur.next = new_car

    def show(self):
        """从头到尾报出车厢号"""
        cars = []
        cur = self.head
        while cur is not None:
            cars.append(str(cur.no))
            cur = cur.next
        print("列车:", " -> ".join(cars))

    def remove(self, no):
        """摘掉编号为 no 的车厢"""
        dummy = Car(0)          # 哨兵车厢,让删第一节也好写
        dummy.next = self.head
        cur = dummy
        while cur.next is not None:
            if cur.next.no == no:
                cur.next = cur.next.next
                break
            cur = cur.next
        self.head = dummy.next

train = Train()
for no in ["W1", "W2", "W3"]:
    train.add_tail(no)
    train.show()

train.remove("W2")
print("摘掉 W2 后:")
train.show()

train.add_tail("W9")
print("挂上 W9 后:")
train.show()
运行结果OUTPUT
列车: W1
列车: W1 -> W2
列车: W1 -> W2 -> W3
摘掉 W2 后:
列车: W1 -> W3
挂上 W9 后:
列车: W1 -> W3 -> W9

链表不怕中间拆装:改一改 next 挂钩就行;双向链表、循环链表是它的升级版。

在新标签运行和修改这个实例已装入本课代码 · 可自定义输入 · 可提交判题

04 · 逐步理解

每一步只解决一个问题

  1. 01

    列表的烦恼与链表的主意

    列表的元素在内存里排排坐,中间插一个,后面全体挪窝。链表换了思路:每节车厢(节点)自带一个挂钩(next),指向下一节——拆装车厢只需改挂钩,谁也不用挪。

  2. 02

    节点类 Car

    每个节点只装两样东西:数据 no 和指针 next。刚造出来的车厢 next 是 None,表示“还没挂到任何车上”。这就是链表的细胞。

    PYTHON
    class Car:
        def __init__(self, no):
            self.no = no
            self.next = None
  3. 03

    找到车尾挂新车

    从 head 出发,沿着 next 一站一站往后走,直到 next 为 None——那就是车尾。把新车挂上去,车尾立刻换人。空车(head 为 None)是特殊情况,要单独处理。

    PYTHON
    while cur.next is not None:
        cur = cur.next
    cur.next = new_car
  4. 04

    顺链遍历

    while cur is not None: ... cur = cur.next 是链表遍历的万能句式。cur 像检票员,从车头一路走到车尾,每节车厢都报到。

    PYTHON
    while cur is not None:
        cars.append(str(cur.no))
        cur = cur.next
  5. 05

    摘除车厢:让挂钩跳过它

    删除 W2,不需要碰到 W2 本身:只要让前一节的挂钩“跳过”它,指向后一节。加一个 next 指向车头的哨兵节点,连“删第一节”都不用特判。

    PYTHON
    cur.next = cur.next.next
  6. 06

    双向链表与循环链表(了解)

    给车厢再加一个 prev 后向挂钩,就是能双向行走的双向链表;让车尾挂回车头,就围成了循环链表。结构越灵活,操作时要小心的挂钩越多。

  7. 07

    链表 vs 列表

    列表按下标秒查,链表要从头走;链表中间拆装快,列表要搬家。没有万能的结构,只有合适的场景——这是数据结构课最重要的一句话。

05 · 练习与检验

自己写出来,才算真正学会

本课实作步骤
  1. 1运行调度系统,挂上三节车厢
  2. 2在中间插入一节新车厢
  3. 3摘掉坏掉的 W2 车厢
  4. 4从头到尾打印整列车验收
打开本课编程实验室编辑、运行、测试、判题都在一个页面完成

06 · 完整知识

继续理解定义、规则和适用边界

第一次学习先完成上面的六个步骤;需要查定义、核对规则、分析误区或理解“为什么”时,再展开对应知识章。

程序组织类、对象、属性与方法理解对象模型和封装边界,用类表达有状态的实体,而不是把所有程序都强行改成类。

正式定义

类描述一类对象的数据与行为;实例是类创建的具体对象。实例方法的第一个参数通常命名为 self,用来访问当前实例;__init__ 在实例创建后负责初始化状态。

必须掌握

  • 实例属性通常在 __init__ 中通过 self.name = value 建立。
  • 实例方法通过 object.method() 调用;Python 会自动把实例绑定给 self。
  • 类属性由实例共享,实例属性属于单个对象;同名实例属性会遮蔽类属性。
  • __repr__ 面向开发与调试,__str__ 面向用户显示;特殊方法应遵守其协议。
  • 继承表达“是一种”关系,组合表达“拥有一个”关系;能用组合清晰表达时不要滥用继承。
  • 对象相等默认仍是身份比较;需要按内容相等时要定义相应协议。

常见误区

  • 在方法中漏写 self
  • 把每个实例独有的可变数据写成类属性
  • 只为包装几个无状态函数而建类
  • 继承层次过深导致行为难以追踪

适用边界

  • 课程使用普通类解释对象模型;dataclass、property、抽象基类和元类是后续工程工具。
  • 算法题常用函数和基本容器更直接,不要求为了“面向对象”而增加结构。
打开本章完整示例与独立阅读页 →
Python 基础条件、循环与程序流程准确理解 if、for、while、range、break、continue 和循环嵌套,而不是背代码模板。

正式定义

控制流决定下一条要执行的语句。分支依据布尔条件选择路径;循环在满足规则时重复执行代码块。Python 用冒号和缩进界定代码块。

必须掌握

  • if/elif/else 从上到下判断,只执行第一个为真的分支;else 不写条件。
  • for 依次取得可迭代对象中的元素;range(start, stop, step) 包含 start、不包含 stop,step 不能为 0。
  • while 在每轮开始前检查条件;循环体必须让状态向终止条件推进。
  • break 结束最内层循环,continue 跳过本轮剩余语句,循环的 else 仅在没有被 break 终止时执行。
  • 嵌套循环的总执行次数通常需要把各层次数相乘;内层 break 不会结束外层循环。
  • 边界测试至少覆盖空范围、单个元素、第一项命中、最后一项命中和始终不命中。

常见误区

  • range 的右端点多算或少算一次
  • while 忘记更新状态造成死循环
  • 把两个互斥条件写成两个独立 if
  • 误以为 break 会跳出所有嵌套循环

适用边界

  • 流程图是算法的表示方法,不是 Python 语法。
  • 递归也能表达重复,但有调用开销和递归深度限制,不能无条件代替循环。
打开本章完整示例与独立阅读页 →
核心数据结构列表、元组、字典与集合按顺序、可变性、唯一性和查找需求选择容器,并掌握遍历、推导式、排序与复制。

正式定义

容器保存多个对象。list 是可变有序序列,tuple 是不可变有序序列,dict 保存唯一键到值的映射,set 保存无序且不重复的可哈希对象。

必须掌握

  • list 支持下标、切片、append、extend、insert、pop、remove 与 sort;多数修改方法返回 None。
  • tuple 的逗号比括号更关键,单元素元组必须写成 (value,)。
  • dict 保持插入顺序;键必须可哈希且唯一,get 可提供缺省值,items 同时遍历键和值。
  • set 用于去重与集合运算:| 并、& 交、- 差、^ 对称差;空集合必须写 set()。
  • enumerate 同时给出序号和值,zip 并行遍历多个可迭代对象,默认在最短输入处停止。
  • 浅复制只复制最外层容器;嵌套可变对象仍可能共享。

常见误区

  • 把 list.sort() 的返回值赋回列表
  • 遍历 dict 时同时改变其大小
  • 用可变 list 当字典键
  • 把 set 当成有固定顺序的序列

适用边界

  • 大量从队首删除时 list.pop(0) 是 O(n),应使用 collections.deque。
  • 需要有序映射的特殊操作、计数或默认值时可查阅 collections,但先理解基本 dict。
打开本章完整示例与独立阅读页 →
核心数据结构栈、队列、链表与并查集按访问顺序和更新需求理解线性结构,并掌握各操作的真实代价。

正式定义

栈按后进先出访问,队列按先进先出访问,链表用节点引用连接次序,并查集维护元素所属的动态不相交集合。数据结构的价值在于为特定操作提供清晰语义和复杂度保证。

必须掌握

  • Python list 的尾部 append/pop 可作栈,均摊 O(1)。
  • 队列应使用 collections.deque 的 append/popleft,避免 list.pop(0) 的 O(n) 搬移。
  • 循环队列用固定数组、队首队尾下标和取模复用空间,必须约定空与满的判定。
  • 单链表节点保存值和 next;已知前驱时插入删除 O(1),按下标查找仍是 O(n)。
  • 并查集的 find 找代表元,union 合并集合;路径压缩与按大小/秩合并使均摊代价近似常数。
  • 选择结构前先列出最频繁操作:随机访问、两端操作、按键查找或集合合并。

常见误区

  • 用 pop(0) 实现大规模队列
  • 空栈空队列仍然弹出
  • 链表改指针时丢失后续节点
  • 并查集只改父节点却不理解代表元

适用边界

  • Python 没有课程必需的内置链表类型,教学实现用于理解指针关系;工程中应根据实际操作选择成熟容器。
  • 并查集擅长连通性合并,不支持高效删除或一般最短路。
打开本章完整示例与独立阅读页 →

完成检查

确认自己会解释、会编写、会验证