链表：用一串对象自己拼出一个序列

0. 本讲导读

到这一讲为止，你处理「一串东西」时用的一直是 Python 的内置列表 [1, 2, 3]。它太顺手了，顺手到你从来没问过一个问题：这个东西在内存里到底长什么样？它做每件事分别要花多少代价？

本讲就是拿这个问题开刀。答案会告诉你：Python 列表在「往开头插一个元素」这件事上慢得离谱，慢到同一个任务从 0.68 秒变成 0.00095 秒的差距。而修好它的办法不是去优化 Python 列表，而是换一种数据结构——一种你自己用几行的类就能写出来的结构：链表（linked list）。

链表的定义只有一句话，而且是递归的：一个链表要么是空的，要么装着「第一个值」和「剩下的链表」。这句话你应该觉得眼熟——上一讲的树（tree）是「一个根标签 + 一串子树」，同样是用自己定义自己。递归数据结构（recursive data structure）这个套路在本讲会被再敲一遍，而且敲得更狠：链表比树更简单，所有注意力都会落在「递归调用怎么展开、怎么回代」上面。

本讲要回答的三个问题：

• 为什么要造它——Python 列表在什么地方付不起代价，链表凭什么便宜。
• 它是怎么被表示的——一个 Link 类、两个实例属性 first 和 rest、一个当哨兵用的类属性 Link.empty。
• 怎么在它上面写代码——递归版和迭代版各写一遍，看清「lnk.rest 本身也是一个完整的链表」这句话在代码里长什么样。以及最要命的一节：变异（mutate）现有链表和返回一个新链表是两件完全不同的事，写错了 doctest 会以最莫名其妙的方式失败。

往前看：本讲的全部前置知识是第 12–13 讲的类与实例属性（self.first = first 就是在实例上绑名字）、第 8 讲的可变性与别名，以及第 9–15 讲那套递归思路。往后看：下一讲讲效率，届时「Python 列表 vs 链表」这张代价表会被正式地用 $\Theta$ 记号写出来；链表本身则会在 Scheme 那几讲里以语言内置数据结构的身份原样回来——Scheme 的 pair 就是 Link，只不过名字叫 car 和 cdr。

1. 为什么不能一直用 Python 列表

先摆事实。课上演示的那个基准测试做的事情很单纯：往一个序列的开头反复插入元素。同样的任务：

七百倍。这不是常数因子上的小胜负，是量级上的差别，说明两者做同一件事的做法根本不同。

动态数组：为什么头部插入这么贵

Python 列表底层是一块连续的内存。「连续」是它最大的优点，也是它唯一的软肋。

优点在于：元素挨个排好，第 i 个元素的地址可以直接用「起始地址 + i × 每格大小」算出来，不用挨个走。所以 lst[5000] 和 lst[0] 一样快——这叫随机访问（random access）。

软肋在于：既然「第 i 个元素必须在第 i 格」，那你要在最前面塞一个新元素，原来的第 0 个就必须挪到第 1 格，第 1 个挪到第 2 格……每一个元素都得往后搬一格。

插入前：  [ a ][ b ][ c ][ d ][   ]      ← 连续的 5 格，用了 4 格

搬运：    [ a ][ b ][ c ][ d ][ d ]      d 往后挪
          [ a ][ b ][ c ][ c ][ d ]      c 往后挪
          [ a ][ b ][ b ][ c ][ d ]      b 往后挪
          [ a ][ a ][ b ][ c ][ d ]      a 往后挪

写入：    [new][ a ][ b ][ c ][ d ]      第 0 格才空出来

n 个元素 → n 次搬运。插 n 次 → n² 次搬运。

基准测试里反复往头部插入，于是这个「每次 n 次搬运」被乘上了插入次数，0.68 秒就是这么来的。（还有一层：连续的那块内存装满以后，Python 得另找一块更大的、把全部内容复制过去。这一步平摊下来不贵，但也是「必须连续」带来的额外负担。）

代价换代价，不是白拿的

链表不是「更好的列表」，它是另一套取舍。手拉手的队伍虽然队首插人便宜，但你想找「第 5000 个人」，就只能从队首开始一个一个数过去——没有座位号可用。

所以「用哪个」取决于你的程序主要在做什么。这门课选择讲链表，除了这个工程理由，还有一个更重要的教学理由：链表是一个递归定义的数据结构，而且它简单到你能把每一步都在纸上画出来。它是练习递归思维的绝佳靶子。

2. 定义：一句递归的话

课上给出的定义只有两行，请把它当公理背下来：

这个定义有两个地方值得停下来想。

第一，它是递归的。第 2 条里出现了「链表」这个词本身。你可能会觉得这是在耍赖——用一个词解释它自己。但它不是耍赖，因为有第 1 条：空表这个 case 不引用自己。第 2 条每往下剥一层，「剩下的链表」就比原来短一个元素，剥够了必然落到第 1 条上停住。这正是递归函数里 base case 和 recursive case 的关系，只不过这次它出现在数据上而不是函数上。

第二，「剩下的」是一个完整的链表，不是「几个散元素」。这是全讲最容易含糊过去、也最要命的一点。对于存着 7、9、3 的那个链表 lnk：

• lnk.first 是 7，一个整数。
• lnk.rest 是存着 9 和 3 的那个链表——它自己也有 .first（是 9）和 .rest（是存着 3 的那个链表）。

课上给了个比喻：链条上的环（links in a chain）。这也是这个类叫 Link 而不叫 LinkedList 的原因——你手上拿到的那个对象，严格来说是一个环；但因为这个环拉着后面所有的环，它同时也代表着从这里往后的整条链子。一个对象既是「一个节点」又是「一整个链表」，这正是递归数据结构的特征。

递归地看 vs 相对地看

课上强调：链表和树一样，可以递归地（recursively）看，也可以相对地（relatively）看。这两种视角对应两种写代码的方式，都要会。

3. Link 类：三个部件，一个都不能少

CS 61A 里链表用我们自己写的 Link 类表示。核心部分就这几行：

class Link:
    empty = ()

    def __init__(self, first, rest=empty):
        assert rest is Link.empty or isinstance(rest, Link)
        self.first = first
        self.rest = rest

短得有点过分，但每一行都在解决一个具体问题。逐行拆。

empty = ()：一个当哨兵用的类属性

这一行写在类体里、不在任何方法里，所以它是类属性（class attribute）：整个程序中只有一份，属于 Link 这个类本身，所有实例共享。

它的值是 ()，空元组。为什么选空元组？因为需要一个「表示空表」的标记物，而这个标记物必须满足两个条件：

1. 不可变——它是全局唯一的哨兵，谁都不该改它。元组不可变，正合适。
2. 身份唯一——所有的空表都应该是同一个对象，这样才能用 is 快速判断。

换句话说，() 这个具体选择本身不重要，重要的是大家都用 Link.empty 这个名字去引用它。

rest=empty：默认参数让「只有一个元素」变得好写

形参 rest 的默认值是 empty。注意这里写的是光秃秃的 empty 而不是 Link.empty——因为 def 这一行是在类体正在被执行的时候求值的，此刻 Link 这个名字还没绑定好，但类体这个局部作用域里 empty 已经有了。（这也是为什么函数体里必须写全 Link.empty：函数体是调用时才执行的。）

有了这个默认值，造「只有一个元素的链表」就只要写 Link(5)，不用写 Link(5, Link.empty)。这在嵌套构造时省下大量括号：

>>> s = Link(3, Link(4, Link(5)))     # 最里层的 Link(5) 用了默认的 rest

assert：把「rest 必须是链表」这条规矩钉死

assert rest is Link.empty or isinstance(rest, Link)

这一行在说：能放进 rest 的东西只有两种——空表哨兵，或者另一个 Link 实例。别的一律不行。

为什么要拦？因为定义里说得清清楚楚：「剩下的那个链表」。如果允许 Link(1, 2) 存在，那 lnk.rest.first 就会崩，所有依赖递归定义的函数全部失效。把这条规矩写成 assert，好处是错误在造出坏数据的那一刻就爆炸，而不是等到很久以后某个函数走到那里才莫名其妙地崩——后者调试起来痛苦十倍。

亲手试一下它长什么样（这是本机跑出来的真实输出）：

>>> Link(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "link.py", line 5, in __init__
    assert rest is Link.empty or isinstance(rest, Link)
AssertionError

注意 AssertionError 后面什么信息都没有——因为这条 assert 没写错误消息。看到光秃秃的 AssertionError 而且 traceback 最后一行指向 Link.__init__，你就该立刻想到：我给 rest 传了个不是链表的东西。

顺带一提，first 上没有任何限制。链表里可以装任何东西：整数、字符串、列表、函数，甚至另一个链表。这在后面会造出有意思的显示结果。

两个实例属性

self.first = first
self.rest = rest

这两行是实例属性（instance attribute）赋值：每造一个 Link，就在这个新对象上绑两个名字。所以「链表」这个数据结构说到底就是：一堆散落在内存各处的小对象，每个对象记着一个值和一个「下一个是谁」的引用。它们之间没有任何「连续」的要求，这正是头部插入便宜的根源。

>>> s = Link(3, Link(4, Link(5)))
>>> s.rest.rest.rest          # 走到了末尾，这是 Link.empty
()
>>> s.rest.rest.rest.first
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'first'

4. __repr__ 与 __str__：同一个链表的两种打印

光有 first 和 rest，链表已经能用了。但如果你在交互式解释器里敲 s，看到的会是这种东西：

<__main__.Link object at 0x7f3a2c1d4e50>

毫无信息量。所以 Link 还定义了两个特殊方法，让链表能被人看懂。这两个方法在第 13 讲见过，这里是它们第一次被用在递归结构上。

__repr__：打印出「怎么造出它」的那行代码

def __repr__(self):
    if self.rest is not Link.empty:
        rest_repr = ', ' + repr(self.rest)
    else:
        rest_repr = ''
    return 'Link(' + repr(self.first) + rest_repr + ')'

__repr__ 的设计目标是忠实：给出的字符串应该能原样粘回解释器、造出一个一样的对象。所以它输出的正是 Link(3, Link(4, Link(5))) 这种形式。

注意它自己就是个递归函数，只是没直接写函数名——repr(self.rest) 会去调用 self.rest 的 __repr__，那又是一个 Link，于是又调一层。三个部件对应得很整齐：

还有一处细节：拼接第一个值时用的是 repr(self.first) 而不是 str(self.first)。这让字符串元素带上引号，从而保持「粘回去能重造」的承诺：

>>> Link('cat', Link('dog'))
Link('cat', Link('dog'))

如果这里用 str，输出会是 Link(cat, Link(dog))——粘回解释器就是 NameError 了。

__str__：打印成人读的样子（而且是迭代写的）

def __str__(self):
    string = '('
    while self.rest is not Link.empty:
        string += str(self.first) + ' '
        self = self.rest
    return string + str(self.first) + ')'

__str__ 的目标是好看，所以它输出 (3 4 5)——元素之间空格分隔，两边一对括号。（这个格式不是随便选的，它就是 Scheme 显示列表的格式。这一讲埋的伏笔，会在讲 Scheme 的时候收。）

这段代码有个非常值得学的地方：它把 self 当普通局部变量重新绑定了。

两个方法的对照

doctest 检查的是 __repr__ 的输出——因为 doctest 模拟的是「在解释器里敲一行」。所以本讲所有 doctest 里期望值都写成 Link(...) 形式；只有显式写了 print(...) 的那几行才会看到 (...) 形式。写作业时看清楚 doctest 里有没有 print，这决定了你该对哪种输出负责。

5. 走链表：.first 和 .rest 的连招

访问链表元素没有下标，只有顺着 rest 一步步走。规律非常机械：要拿第 i 个元素，就写 i 个 .rest 再加一个 .first。

>>> s = Link(1)
>>> s.first
1
>>> s.rest is Link.empty
True
>>> s = Link(3, Link(4, Link(5)))
>>> s
Link(3, Link(4, Link(5)))
>>> print(s)
(3 4 5)

链表不支持的那些操作

Link 是我们手写的类，Python 内置列表的那些便利它一概没有。下面每一条都是本机跑出来的真实报错：

>>> s = Link(3, Link(4, Link(5)))
>>> len(s)
TypeError: object of type 'Link' has no len()
>>> s[0]
TypeError: 'Link' object is not subscriptable
>>> for x in s:
...     print(x)
TypeError: 'Link' object is not iterable

这些「不支持」不是缺陷，是本讲的教学意图：把便利拿掉，你才会被迫直面「遍历一个序列到底是怎么回事」。

WWPD：print(Link(Link(5), 6))

课上的第一道 What Would Python Display。先别急着读下去，自己想 20 秒。

>>> print(Link(Link(5), 6))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "link.py", line 5, in __init__
    assert rest is Link.empty or isinstance(rest, Link)
AssertionError

>>> Link(Link(5), Link(6))
Link(Link(5), Link(6))
>>> print(Link(Link(5), Link(6)))
((5) 6)

6. length：同一个函数，递归写一遍，迭代写一遍

第一个真正的链表函数：数一数链表里有几个元素。它足够简单，可以把两种视角都完整演示一遍。

递归版

def length(lnk: Link) -> int:
    """Returns the length of a linked list"""
    if lnk is Link.empty:
        return 0
    return 1 + length(lnk.rest)

两行。但这两行里藏着链表递归的标准骨架，后面每个函数都是它的变体：

第 ③ 步是全讲的关键：你敢把 lnk.rest 直接传给 length，唯一的理由是「剩下的也是一个链表」这条定义。如果 rest 存的是别的形式，这行代码就不成立。数据结构的递归定义和函数的递归写法，是严丝合缝对上的。

length(C)   lnk=C   C 不是空 → 返回 1 + length(B)      ← 等 length(B)
  length(B)   lnk=B   B 不是空 → 返回 1 + length(A)    ← 等 length(A)
    length(A)   lnk=A   A 不是空 → 返回 1 + length(())  ← 等 length(())
      length(())  lnk=()  是空！ → 直接 return 0        ← base case，栈到底了

注意每一帧的 parent 都是 Global，不是「上一帧」。函数的父帧由定义位置决定（length 定义在全局），跟谁调用了它没关系——这是第 4 讲的规则，在递归里同样成立。所以 f4 里查不到的名字会去 Global 找，不会去 f3 找。

迭代版

def length(lnk: Link) -> int:
    """Returns the length of a linked list"""
    curr = lnk
    total = 0
    while curr is not Link.empty:
        total += 1
        curr = curr.rest
    return total

这是「相对视角」的写法：curr 是一个游标，从头开始，每轮往后挪一格，挪不动了（碰到 Link.empty）就停。第 2 讲讲循环时说的三件事——初始化、条件、更新——在这里对应得很干净：

7. double：变异原表，还是造一张新表？

这是本讲最重要的一节。同一个需求「把链表里每个数翻倍」，有两种完全不同的实现，它们的函数签名、返回值、对原表的影响全都不同。分不清这两者，你的链表代码会以最难查的方式出错。

版本一：就地变异（in place）

def double(lnk: Link):
    """Doubles a linked list in place (e.g. only mutates it)
    >>> s = Link(2, Link(3, Link(4)))
    >>> double(s)
    >>> s
    Link(4, Link(6, Link(8)))
    """
    if lnk is not Link.empty:
        lnk.first *= 2
        double(lnk.rest)

先读 doctest，它把这个函数的契约说得很清楚：

• >>> double(s) 这一行下面没有期望输出——意思是「这个调用返回 None」。函数体里确实一个 return 都没有。
• >>> s 显示的是翻倍后的结果——原来那个 s 被改掉了。

再看代码结构，它跟递归骨架相比有个明显的差别：base case 什么都不做。写成 if lnk is not Link.empty: 而不是 if lnk is Link.empty: return，效果一样——空表就是没什么可翻倍的，直接结束。

关键的两行：

• lnk.first *= 2：改的是对象。lnk 指着的那个 Link 实例，它的 first 属性被换成了新值。谁还指着这个实例，谁就看得见这个改动——包括调用方手里的 s。
• double(lnk.rest)：递归调用的结果被丢掉了（既没赋值也没 return）。这不是 bug——我们要的不是它的返回值，是它顺手改掉后面所有节点这个副作用。

调用前：
  s ──→ [ 2 | ·]──→ [ 3 | ·]──→ [ 4 | / ]
          P           Q           R

调用后：
  s ──→ [ 4 | ·]──→ [ 6 | ·]──→ [ 8 | / ]
          P           Q           R      ← 还是同样这三个对象！

版本二：造一张新表

def double(lnk: Link) -> Link:
    """
    Returns a new linked list which is
    the result of doubling the input
    >>> s = Link(2, Link(3, Link(4)))
    >>> double(s)
    Link(4, Link(6, Link(8)))
    >>> s
    Link(2, Link(3, Link(4)))
    """
    if lnk is Link.empty:
        return Link.empty
    else:
        return Link(lnk.first * 2, double(lnk.rest))

同名同参，doctest 却完全不同——差别就在这两行：

• >>> double(s) 这一行下面有期望输出 Link(4, Link(6, Link(8)))，说明它返回了一个链表。
• >>> s 显示的还是 Link(2, Link(3, Link(4)))——原表纹丝不动。

代码上的三处对应改动：

double(P)  P.first=2  → 要 return Link(4, double(Q))    ← 等 double(Q)
  double(Q)  Q.first=3  → 要 return Link(6, double(R))  ← 等 double(R)
    double(R)  R.first=4  → 要 return Link(8, double(())) ← 等 double(())
      double(())  是空 → return Link.empty              ← base case

  s ──→ [ 2 | ·]──→ [ 3 | ·]──→ [ 4 | / ]      ← 原表，一个字节没动
          P           Q           R

  t ──→ [ 4 | ·]──→ [ 6 | ·]──→ [ 8 | / ]      ← 全新的三个对象
          P'          Q'          R'

本机实测确认它们确实不共享任何节点：double(s) is s 是 False，double(s).rest is s.rest 也是 False。

怎么一眼分辨自己该写哪一种

看 docstring 和 doctest，三个信号：

**********************************************************************
File "16.py", line 5, in 16.double
Failed example:
    double(s)
Expected nothing
Got:
    Link(4, Link(6, Link(8)))
**********************************************************************

>>> s = Link(2, Link(3, Link(4)))
>>> double(s)          # 造新版，返回值没接住
Link(4, Link(6, Link(8)))
>>> s                  # 你以为 s 变了？
Link(2, Link(3, Link(4)))

Traceback (most recent call last):
  File "16.py", line 6, in <module>
    double(Link(2, Link(3)))
  File "16.py", line 5, in double
    return Link(lnk.first*2, double(lnk.rest))
  File "16.py", line 5, in double
    return Link(lnk.first*2, double(lnk.rest))
  File "link.py", line 5, in __init__
    assert rest is Link.empty or isinstance(rest, Link)
AssertionError

8. 实战一：filter_link

课堂练习第一题，起始代码在 16.py：

def filter_link(f, lnk: Link) -> Link:
    """
    Return a Link that contains only the elements of `x` inside `lnk`
    for which `f(x)` is a truthy value.

    >>> is_odd = lambda x: x % 2 == 1
    >>> lnk = Link(1, Link(2, Link(3, Link(4, Link(5)))))
    >>> filter_link(is_odd, lnk)
    Link(1, Link(3, Link(5)))
    >>> lnk  # no mutation!
    Link(1, Link(2, Link(3, Link(4, Link(5)))))

    >>> short = lambda x: len(x) <= 3
    >>> lnk = Link('bottle', Link('cat', Link('dog', Link('gateway', Link('a')))))
    >>> filter_link(short, lnk)
    Link('cat', Link('dog', Link('a')))
    >>> lnk  # no mutation!
    Link('bottle', Link('cat', Link('dog', Link('gateway', Link('a')))))
    """

题目到底要什么

翻成人话：造一个新链表，只留下那些让 f(x) 为真的元素，顺序不变。它就是内置 filter 的链表版。

docstring 和 doctest 里有几处必须读出来的信息：

• "Return a Link" + -> Link 标注 + 调用那行有期望输出 → 造新版，不是变异版。
• # no mutation! 这条注释是全题的重点。它明确要求：跑完之后原链表必须一模一样。这排除了「顺手改改原表的 rest 把不要的节点跳过去」这种取巧写法。
• "truthy value" 而不是 "True"——用 if f(x) 就对了，别写 if f(x) == True。第 2 讲讲过真假性。
• 第二组 doctest 里 f 是 short = lambda x: len(x) <= 3，元素是字符串——提醒你 f 是个参数，函数体里绝不能假设元素是数字。

边界情况（doctest 没直接测，但你的代码必须扛得住）：输入是空表 → 返回空表；所有元素都被过滤掉 → 返回 Link.empty 而不是崩掉或返回 None（这条最容易漏）；只有第一个或只有最后一个元素被留下 —— 拼接逻辑要能处理。

怎么想到的

从「输出是个链表」这一点出发，先把递归骨架的空架子摆出来：

def filter_link(f, lnk):
    if lnk is Link.empty:
        return Link.empty          # 空表过滤完还是空表
    ...                            # 这里要用 lnk.first 和 filter_link(f, lnk.rest)

base case 想都不用想：空表里没有元素，过滤完当然还是空表。注意必须 return Link.empty，不能光写 return——上一节已经演示过后者会怎么炸。

递归 case 的关键一问：假设 filter_link(f, lnk.rest) 已经神奇地把后面那截过滤好了（这是递归的「信仰之跃」），我拿这个结果怎么拼出完整答案？

答案分两种情况，取决于当前这个元素该不该留：

第 2 种情况是这道题唯一有点意思的地方。很多人在这里会卡住，想「扔掉了要返回什么呢？」——要返回的就是后半截本身。「跳过这一个」在造新表的写法里表现为「不给它包一层新 Link」，仅此而已。原表的那个节点还好好地待在原表里，我们只是没有为它造对应的新节点。

代码逐行讲

def filter_link(f, lnk: Link) -> Link:
    if lnk is Link.empty:
        return Link.empty

    filtered_rest = filter_link(f, lnk.rest)
    if f(lnk.first):
        return Link(lnk.first, filtered_rest)
    else:
        return filtered_rest

验证：手动追踪 filter_link(is_odd, Link(1, Link(2, Link(3))))

为了写得下，用三个元素的版本；五个元素的过程完全一样。把节点记作 N1(1) → N2(2) → N3(3)。

filter_link(is_odd, N1)   非空 → 先算 filter_link(is_odd, N2)      ← 挂起
  filter_link(is_odd, N2)   非空 → 先算 filter_link(is_odd, N3)    ← 挂起
    filter_link(is_odd, N3)   非空 → 先算 filter_link(is_odd, ())  ← 挂起
      filter_link(is_odd, ())   是空 → return Link.empty          ← base case

原表（没被碰过）：
  lnk ──→ [ 1 | ·]──→ [ 2 | ·]──→ [ 3 | / ]
            N1          N2          N3

结果表（全是新对象）：
  M1  ──→ [ 1 | ·]──────────────→ [ 3 | / ]
            M1                      M3

两条链子没有共享任何节点：filter_link(...).rest is lnk.rest.rest → False

filtered_rest = filter_link(f, lnk.rest)
if f(lnk.first):
    lnk.rest = filtered_rest      # ← 复用原节点，改它的 rest
    return lnk
return filtered_rest

**********************************************************************
File "16.py", line 8, in 16.filter_link
Failed example:
    lnk  # no mutation!
Expected:
    Link(1, Link(2, Link(3, Link(4, Link(5)))))
Got:
    Link(1, Link(3, Link(5)))
**********************************************************************

9. 实战二：insert——链表最擅长的那件事

课堂练习第二题。这题正好把第 1 节那个「链表凭什么快」的承诺兑现：插入不需要挪动任何元素，只需要改一个 rest。

def insert(lnk: Link, index: int, value):
    """
    Mutate `lnk` to insert `value` at `index`.
    Assume that 0 < `index` <= the length of `lnk`.

    >>> lnk = Link('cat', Link('dog', Link('a')))
    >>> insert(lnk, 1, 'fish')
    >>> lnk
    Link('cat', Link('fish', Link('dog', Link('a'))))

    >>> lnk = Link(1, Link(2, Link(3, Link(4, Link(5)))))
    >>> insert(lnk, 3, 'yay')
    >>> lnk
    Link(1, Link(2, Link(3, Link('yay', Link(4, Link(5))))))

    >>> lnk = Link(1, Link(2, Link(3, Link(4, Link(5)))))
    >>> insert(lnk, 5, 6)
    >>> lnk
    Link(1, Link(2, Link(3, Link(4, Link(5, Link(6))))))
    """

题目到底要什么

「把 value 插到 lnk 的第 index 位」——插完之后，新值应该正好能用 index 个 .rest 加一个 .first 取到。

四个必须读出来的信息：

• "Mutate" + 调用那行 doctest 下面没有期望输出 + 之后单独看 lnk 发现变了 → 这是变异版。函数不返回任何东西。
• 0 < index：不需要处理 index 为 0 的情况。课上专门给了这个提示，而且它不是「为了让题简单」——见下面的 warn 框，这是链表的一个根本限制。
• index <= 长度：index 可以正好等于长度，也就是插到末尾（第三组 doctest 就是这个：长度 5 的链表，insert(lnk, 5, 6) 把 6 挂到最后）。这是最容易写崩的边界。
• 插入是在「原来第 index 个元素之前」——看第一组：('cat' 'dog' 'a') 插 index=1 得到 ('cat' 'fish' 'dog' 'a')，'fish' 占了原本 'dog' 的位置，'dog' 往后退。

怎么想到的

先想清楚「插入」这个动作在方框-箭头图上到底是什么。要在 ('cat' 'dog' 'a') 的 index=1 处插 'fish'：

插入前：
  lnk ──→ [cat| ·]──→ [dog| ·]──→ [ a | / ]
            N1          N2          N3

插入后：
  lnk ──→ [cat| ·]──→ [fish| ·]──→ [dog| ·]──→ [ a | / ]
            N1          NEW          N2          N3
                 ↑改了这一个 rest    ↑N2、N3 完全没动

只有两件事发生了：造一个新节点 NEW，它的 first 是 'fish'、rest 是原来 N1 的 rest（也就是 N2）；然后把 N1 的 rest 改成 NEW。N2、N3 一个字节都没动——这就是链表插入 $\Theta(1)$ 的全部内容。

于是问题变成：怎么找到「第 index-1 个节点」？因为要改的是它的 rest。找到之后，插入动作永远是同样两行。

递归版

def insert(lnk: Link, index: int, value):
    if index == 1:
        temp = lnk.rest
        lnk.rest = Link(value, temp)
    else:
        insert(lnk.rest, index - 1, value)

递归的思路是：「在 lnk 的第 index 位插入」等价于「在 lnk.rest 的第 index−1 位插入」——每往后走一个节点，目标位置就近一格。一直走到 index == 1，此刻 lnk 正好站在「要插入位置的前一个节点」上，动手。

insert(N1, 3, 'yay')   index=3 ≠ 1 → insert(N1.rest, 2, 'yay') 即 insert(N2, 2, 'yay')
  insert(N2, 2, 'yay')   index=2 ≠ 1 → insert(N2.rest, 1, 'yay') 即 insert(N3, 1, 'yay')
    insert(N3, 1, 'yay')   index=1 → 动手！

前：
  lnk ─→[1|·]─→[2|·]─→[3|·]─→[4|·]─→[5|/]
          N1     N2     N3     N4     N5

后：
  lnk ─→[1|·]─→[2|·]─→[3|·]─→[yay|·]─→[4|·]─→[5|/]
          N1     N2     N3      NEW      N4     N5
                         ↑只有这一个 rest 被赋值过

迭代版

def insert(lnk: Link, index: int, value):
    curr = lnk
    i = 0
    while i < index - 1:
        i += 1
        curr = curr.rest
    temp = curr.rest
    curr.rest = Link(value, temp)

同一个思路换个说法：用游标 curr 往前走 index - 1 步，停在目标位置的前一个节点上，然后做那两行插入。

验证末尾插入这个边界

第三组 doctest 是 insert(lnk, 5, 6)，链表长度正好是 5。这是最容易崩的一组，手动追一遍：

关键在第 2–3 步：temp 是空表这件事完全没问题，因为 Link 的 rest 本来就允许是空表。代码里不需要为「插到末尾」写任何特判——这是它写得漂亮的地方。

if index == 1:
    lnk.rest = Link(value)        # ← 忘了把老的后半截接上

>>> lnk = Link(1, Link(2, Link(3)))
>>> insert(lnk, 1, 'x')
>>> lnk
Link(1, Link('x'))

AttributeError: 'tuple' object has no attribute 'rest'

Failed example:
    lnk
Expected:
    Link(1, Link(2, Link(3, Link(4, Link(5, Link(6))))))
Got:
    Link(1, Link(2, Link(3, Link(4, Link(5, Link(6, Link(6, Link(6,
    Link(6, Link(6, Link(6)))))))))))

两种写法的对照

最后一行值得强调：这两种写法能生效，靠的是同一个原理——函数拿到的是「指向同一批节点的引用」，改节点属性，所有指着它的人都看得见。第 8 讲讲别名（aliasing）时说的话，在这里变成了一个功能而不是一个陷阱。

10. 收束：链表在这门课里的位置

链表和树是同一套思路的两个实例

把上一讲的树和本讲的链表并排放，会发现它们的骨架一模一样：

本质区别只有一个：树的递归是分叉的，链表的递归是线性的。正因为不分叉，链表的递归可以逐字改写成 while 循环（本讲的 length、insert 都演示了），而树的递归一般不行。

还有一个语法差别值得注意：树的空情况通常表现为「branches 是空列表」，此时 t 本身仍是个合法的 Tree；而链表的空情况是 lnk 本身根本不是 Link，什么属性都不能取。这就是为什么链表函数的第一行几乎永远是判空。

元素可以是任何东西，包括另一个链表

first 上没有任何限制，所以链表可以嵌套。看看真实输出：

>>> s = Link(1, Link(Link(2, Link(3)), Link(4)))
>>> s
Link(1, Link(Link(2, Link(3)), Link(4)))
>>> print(s)
(1 (2 3) 4)

这个链表有三个元素：1、Link(2, Link(3))、4。中间那个元素本身是链表，被打成 (2 3)。这种「深链表（deep link）」在 Lab 08 和考试里会出现，处理它们需要两个方向的递归：既往 rest 走（横着），也往 first 走（竖着，用 isinstance(lnk.first, Link) 判断）。Link(1, Link(2)) 和 Link(Link(1), Link(2)) 是完全不同的两个东西。

>>> a = Link(1, Link(2))
>>> a.rest.rest = a          # 最后一个节点指回开头
>>> a
RecursionError: maximum recursion depth exceeded while calling a Python object

往后看

本讲小结

两条骨架，背下来

# 骨架 A：造一张新链表（不改原表）
def f(lnk):
    if lnk is Link.empty:
        return Link.empty
    return Link(用 lnk.first 算出的新值, f(lnk.rest))

# 骨架 B：走一遍并就地修改（不返回值）
def g(lnk):
    curr = lnk
    while curr is not Link.empty:
        改 curr.first 或 curr.rest
        curr = curr.rest

本讲的四个函数全是这两条骨架的变体：length 是 A 的「结果是数不是链表」版和 B 的计数版；double 两个版本正好一 A 一 B；filter_link 是 A 加了个「有时候不包新节点」；insert 是 B 走到指定位置就停。

动手练习

五道题，都请先在纸上或解释器里做完再看答案。前两道是 WWPD 类型，后三道要写代码。所有题目都假定 Link 类已按本讲定义好。

练习 1（WWPD）

>>> a = Link(1, Link(2, Link(3)))
>>> b = a.rest
>>> b.first = 20
>>> a
______
>>> a.rest is b
______
>>> print(a.rest)
______
>>> a.rest.rest.rest
______

>>> a
Link(1, Link(20, Link(3)))
>>> a.rest is b
True
>>> print(a.rest)
(20 3)
>>> a.rest.rest.rest
()

练习 2（WWPD）

下面每一行分别会显示什么？（有的会报错，写出错误类型）

>>> s = Link(1, Link(2))
>>> Link(s, s)
______
>>> print(Link(s, s))
______
>>> Link(1, Link(2), Link(3))
______
>>> len(s)
______

>>> Link(s, s)
Link(Link(1, Link(2)), Link(1, Link(2)))
>>> print(Link(s, s))
((1 2) 1 2)
>>> Link(1, Link(2), Link(3))
TypeError: Link.__init__() takes from 2 to 3 positional arguments but 4 were given
>>> len(s)
TypeError: object of type 'Link' has no len()

练习 3：last

写一个函数返回链表的最后一个值（不是最后一个节点）。假设链表非空。递归和迭代各写一遍。

def last(lnk):
    """
    >>> last(Link(3, Link(4, Link(5))))
    5
    >>> last(Link(7))
    7
    """

def last(lnk):
    if lnk.rest is Link.empty:
        return lnk.first
    return last(lnk.rest)

def last(lnk):
    curr = lnk
    while curr.rest is not Link.empty:
        curr = curr.rest
    return curr.first

练习 4：square_link 的两个版本

把链表里每个数平方。(a) 写一个就地变异的版本 square_in_place；(b) 写一个返回新表的版本 squared。然后回答：跑完 t = squared(s) 之后，t.rest is s.rest 是什么？

def square_in_place(lnk):
    """
    >>> s = Link(2, Link(3, Link(4)))
    >>> square_in_place(s)
    >>> s
    Link(4, Link(9, Link(16)))
    """
    curr = lnk
    while curr is not Link.empty:
        curr.first = curr.first ** 2
        curr = curr.rest

def squared(lnk):
    """
    >>> s = Link(2, Link(3, Link(4)))
    >>> squared(s)
    Link(4, Link(9, Link(16)))
    >>> s
    Link(2, Link(3, Link(4)))
    """
    if lnk is Link.empty:
        return Link.empty
    return Link(lnk.first ** 2, squared(lnk.rest))

练习 5：remove_first（有陷阱）

写一个函数，就地删除链表中第一个等于 value 的元素。假设 value 一定存在，而且不会是第一个元素。删完之后原链表应该少一个节点。

def remove_first(lnk, value):
    """
    >>> s = Link(1, Link(2, Link(3, Link(2))))
    >>> remove_first(s, 2)
    >>> s
    Link(1, Link(3, Link(2)))
    """

提示：想清楚「删除节点 X」在方框-箭头图上是什么动作。

def remove_first(lnk, value):
    curr = lnk
    while curr.rest.first != value:
        curr = curr.rest
    curr.rest = curr.rest.rest

前：  s ─→[1|·]─→[2|·]─→[3|·]─→[2|/]
             N1     N2     N3     N4

后：  s ─→[1|·]─────────→[3|·]─→[2|/]
             N1            N3     N4
              ↑ N1.rest 从 N2 改成了 N3；N2 脱链