树

0. 本讲导读

到目前为止你见过的数据都是「平的」：一个列表装一串数，一个字典装一堆键值对。想表示「这个东西里面还有同样类型的东西，层层套下去」——一个文件夹里有文件夹、一个公司部门下面还有部门、一个算术表达式的操作数还是算术表达式——现有的工具就开始别扭了。

本讲引入树（tree）。树的定义只有一句话，但这句话是递归的：

请盯着最后半句看几秒钟。它就是本讲全部的技术含量所在：数据结构自己是递归的，所以处理它的函数也应该是递归的。在第 6 讲学递归时，你面对的是数字——n 变成 n - 1，那种「变小」是人为约定的。而树不一样：「更小的同类问题」是写在数据结构定义里的，一棵树的分支，天然就是一棵更小的树。你不需要发明如何把问题变小，你只需要把它读出来。

本讲和前后讲的关系是这样的：

• 接上一讲：Lecture 08 讲了抽象数据类型（Abstract Data Type，ADT）——构造器 + 选择器 + 抽象屏障。本讲的树就是一个完整的 ADT 实例：构造器 tree(label, branches)，选择器 label(t) 和 branches(t)。你在上一讲学的「不许越过屏障直接写 t[0]」这条纪律，在本讲会被反复用到——而且这里违反屏障的代价特别大，因为树是嵌套的，你一旦开始手写下标，代码马上会变得没人看得懂。
• 接第 6、7 讲：递归和列表推导式（list comprehension）。本讲几乎每个函数都是「对 branches(t) 里的每一棵子树递归一次，再把结果合起来」，写出来就是一个列表推导式套一个 sum。
• 往后看：Lecture 10 的迭代器与生成器会用 yield from 重写本讲的遍历函数；再往后的 Scheme 部分，程序本身就是树（语法树），本讲的思维方式会原样搬过去。

另外，本讲开头还留了一道上一讲的尾巴：flip_dict。它是字典（dict）的练习，跟树无关，但它示范了一个非常典型的判断——「这个位置现在装的是一个值，还是一个列表？」——所以第 1 节先把它做掉。

1. 热身：flip_dict——上一讲的一条尾巴

题目：写一个 flip_dict(dct)，把字典的键和值对调，返回一个新字典。假设原来的值都能当键用（也就是都不可变）。麻烦在于：原字典里可能有重复的值——两个不同的键映射到同一个值。对调之后这个值成了键，而字典的键不能重复，那对应的多个原键怎么办？

看 doctest 就知道答案：

>>> lengths = {'cat': 3, 'hat': 3, 'bottle': 6, 'a': 1, 'mat': 3, 'an': 2, 'in': 2}
>>> flip_dict(lengths)
{3: ['cat', 'hat', 'mat'], 6: 'bottle', 1: 'a', 2: ['an', 'in']}

规则被 doctest 定死了，一个字都不能猜错：

• 某个值只出现一次 → 新字典里它的值就是那个键本身（6: 'bottle'，不是 6: ['bottle']）。
• 某个值出现多次 → 新字典里它的值是一个列表，按原来的插入顺序装着所有对应的键（3: ['cat', 'hat', 'mat']）。

这个「一个的时候是裸值、多个的时候是列表」的接口其实是很糟糕的设计（调用方每次都得判断类型），但它逼你写出本讲要练的那个判断，所以照做。

思路：边走边升级

难点在于，你在遍历到 'hat' 的时候，并不知道后面还会不会出现第三个长度为 3 的词。所以不能一开始就决定「这个位置该放裸值还是放列表」。办法是边走边升级：默认放裸值，等真的撞上第二个时，再把已经放进去的裸值和新来的键一起打包成列表；从第三个开始就直接往那个列表上 append。

于是每处理一个 (key, val) 都要分三种情况：

区分第 2、3 种情况需要问「new_dct[val] 现在是不是一个 list」。课上给了三种写法：

代码

def flip_dict(dct):
    new_dct = {}
    for key, val in dct.items():
        if val in new_dct:
            if type(new_dct[val]) is list:
                new_dct[val].append(key)
            else:
                new_dct[val] = [new_dct[val], key]
        else:
            new_dct[val] = key
    return new_dct

逐行看：

• dct.items() 一次拿出 (键, 值) 这一对，配合 for key, val in ... 直接解包成两个名字。写成 for key in dct: val = dct[key] 也对，但多一次查表。
• val in new_dct——对字典用 in，查的是键，不是值。这里 val 正是新字典的键，所以问的就是「这个值之前出现过吗」。
• new_dct[val] = [new_dct[val], key]：右边先求值（读出旧的裸值），组成一个两元素列表，再整体赋给左边。右先左后，所以不会读到已经被覆盖的值。
• new_dct[val].append(key)：这一句没有重新绑定字典里的槽位，它是把字典里那个列表对象就地变异了。这正是上一讲讲的可变性——因为 new_dct[val] 和列表本身是同一个对象，改它就等于改字典里的内容。

为什么输出的顺序是那样

拿 lengths 走一遍。Python 3.7 起字典保持插入顺序，所以遍历顺序就是字面量里的书写顺序：

('cat', 3) → 3 不在 → new_dct = {3: 'cat'}
('hat', 3) → 3 在，且是 str → new_dct = {3: ['cat','hat']}
('bottle', 6) → 6 不在 → new_dct = {3: ['cat','hat'], 6: 'bottle'}
('a', 1)   → 1 不在 → {..., 1: 'a'}
('mat', 3) → 3 在，且已是 list → append → {3: ['cat','hat','mat'], ...}
('an', 2)  → 2 不在 → {..., 2: 'an'}
('in', 2)  → 2 在，且是 str → {..., 2: ['an','in']}

注意最后 3 仍然排在最前面：append 和 new_dct[val] = ... 都只是更新已有的键，不会把它挪到末尾。字典的插入顺序只由「这个键第一次被加进来的时刻」决定。

这道题真正和后面有关的一点是：「这个位置装的是一个元素，还是一个装着元素的容器？」这个判断，在树的世界里会以另一种形式回来——「这个东西是一个标签，还是一棵子树？」区别在于，树 ADT 用 is_leaf 把这个判断封装好了，你不用再写 type(...) is list。

2. 树是什么：同一件事的三种说法

课上给了两个定义，加上一个「相对」视角，一共三种说法。它们描述的是同一个东西，但在不同场合好用。

说法一（结构式）：根 + 分支

这张图有三个地方值得停下来想清楚，它们是后面所有 bug 的源头：

• 「节点」和「标签」不是一回事。节点是那个圆圈（连同它下面挂的所有东西），标签只是圈里写的那个值。图里有两个标签都是 1 的节点，但它们是不同的节点。当你写 label(t)，你拿到的是一个数；当你写 branches(t)[0]，你拿到的是一棵树，不是一个数。
• 叶子是树，不是标签。这是初学者最常栽的地方。tree(1) 造出来的东西 [1] 是一棵合法的树，而整数 1 不是。写 tree(3, [1, 2]) 会直接崩：

>>> tree(3, [1, 2])
AssertionError: branches must be trees

• 分支是「一列」，不是「两个」。图上画的都是每个节点最多两个孩子，容易让人以为树就是二叉的。CS 61A 的树 ADT 允许任意多个分支——0 个、1 个、5 个都行。别去写 left = branches(t)[0]; right = branches(t)[1] 这种代码，除非题目明确保证是二叉树（本讲的 fib_tree 就是这样一个例外）。

说法二（递归式）与说法三（相对式）

为什么要有两个说法？因为它们回答不同的问题。

为什么值得学：树在真实世界里到处都是

课上举了四类：

• 文件系统：一个目录里有文件和目录，目录里还有文件和目录。du -sh 算目录总大小，本质就是本讲的 count_leaves 换个合并方式。
• 层级组织：政治的、社会的、公司的架构图。
• 家谱。
• 语法树（syntax tree）：语言学里分析句子结构（LING 100），计算机里分析程序结构（CS 164）。这一条对 61A 尤其重要——课程后半段学 Scheme 时你会发现，Scheme 程序本身就是一棵树，解释器做的事就是在这棵树上递归。

共同点是：层级（谁在谁下面）加上自相似（每一层长得都一样）。只要一个东西满足这两条，树就是它的自然表示。

3. 术语：深度是节点的事，高度是树的事

「深度是节点的性质、高度是树的性质」这句话不是文字游戏，它决定了函数签名长什么样：

• 问深度，你必须指着某个具体节点问，所以「求深度」这类函数通常写成「一边往下走一边把当前深度作为参数传下去」（第 11 节的 count_paths 就是这个套路的近亲）。
• 问高度，你只要给一棵树就够了，所以 height(t) 只需一个参数，而且是标准的树递归形状：

def height(t):
    """返回树 t 的高度（最深叶子的深度）。"""
    if is_leaf(t):
        return 0
    return 1 + max([height(b) for b in branches(t)])

为什么是 1 + max(...)？因为把根挂上去之后，每个分支里所有节点的深度都整体加一。所以「以 t 为根时的最大深度」= 「各分支自己的最大深度」里最大的那个，再加上根到分支根的那一条边。

height(tree(19, [tree(20)]))
  is_leaf? branches = [[20]]，非空 → 不是叶子
  → 1 + max([ height(tree(20)) ])
        height(tree(20)):
            branches = [] → is_leaf 为真 → 返回 0
  → 1 + max([0]) = 1 + 0 = 1

>>> max([])
ValueError: max() arg is an empty sequence

还有几个描述位置关系的词，课上没展开但读题时会碰到，一并列在这里：

4. 树 ADT：构造器与选择器

上一讲的结论是：要表示一种数据，就定义一个构造器负责造，若干选择器负责取，其余代码只准通过它们打交道。树完全照这个套路来。课程给的实现只有八行：

def tree(root_label, branches=[]):
    for branch in branches:
        assert is_tree(branch), 'branches must be trees'
    return [root_label] + list(branches)

def label(tree):
    return tree[0]

def branches(tree):
    return tree[1:]

底层表示：一个「头 + 尾」的列表

一棵树被表示成一个列表：第 0 个元素是根标签，从第 1 个元素开始，每个元素都是一棵子树（也是列表）。

[3, [1], [2, [1], [1]]]
 ↑   ↑    ↑
 │   │    └── 第 2 个分支：根标签 2，两个分支 [1] 和 [1]
 │   └─────── 第 1 个分支：根标签 1，没有分支 → 是叶子
 └─────────── 根标签

画成图：
          3
         / \
        1   2
           / \
          1   1

课上给的交互记录，逐条对照着看：

>>> t = tree(3, [tree(1), tree(2, [tree(1), tree(1)])])
>>> t
[3, [1], [2, [1], [1]]]
>>> label(t)
3
>>> branches(t)
[[1], [2, [1], [1]]]
>>> label(branches(t)[1])
2
>>> is_leaf(t)
False
>>> is_leaf(branches(t)[0])
True

三个关键点：

• branches(t) 返回的是一列树，不是一列标签。所以 branches(t) 的元素不能直接拿去做算术，要先 label 一下——label(branches(t)[1]) 才是 2。
• branches(t)[1] 是第二个分支（下标从 0 开始）。在真实代码里请尽量避免手写下标，用 for b in branches(t)。
• is_leaf(branches(t)[0]) 是 True，因为第一个分支 [1] 只有标签、没有子分支。

逐行读构造器

构造器里两个细节值得说：

（一）assert is_tree(branch) 是干什么的。它在造树的当场检查每个分支确实是树。这行不是必须的（去掉了程序照跑），但它把「传错东西」这个错误提前到出错的那一行暴露出来。没有它，你会在几十行之后某个 label(b) 处收到一句莫名其妙的 TypeError: 'int' object is not subscriptable，然后完全不知道那个 int 是从哪来的。有了它，报错是：

>>> tree(5, [1])
AssertionError: branches must be trees

（二）为什么是 list(branches) 而不是直接 branches。两个理由：

• 兼容性：[root_label] + branches 要求 branches 必须是 list，传元组就报 TypeError: can only concatenate list (not "tuple") to list。加了 list(...) 之后，传元组、传生成器都能用：tree(3, (tree(1), tree(2))) 照样返回 [3, [1], [2]]。
• 切断别名：list(branches) 做的是浅拷贝（shallow copy），造出一个新的外层列表。这样调用方后来往自己那个列表里 append 东西，不会偷偷改到已经造好的树。

>>> b = tree(1)
>>> t = tree(3, [b])
>>> t
[3, [1]]
>>> b.append([2])          # 直接变异 b 这个列表
>>> t
[3, [1, [2]]]              # t 跟着变了！
>>> branches(t)[0] is b
True

抽象屏障：为什么不许写 t[0]

label(t) 的函数体就是 t[0]，那直接写 t[0] 不是更短吗？短是短，但：

顺带说一个真会犯的错：想拿「第一个分支」，写成 t[1] 是对的（因为 t[0] 是标签），但如果你脑子里想的是「branches(t) 的第 0 个」，正确写法是 branches(t)[0]。两者恰好等价，但混着用迟早写错一个。统一走选择器就没有这个问题。

5. is_tree 与 is_leaf：用递归验证递归结构

def is_tree(tree):
    if type(tree) != list or len(tree) < 1:
        return False
    for branch in branches(tree):
        if not is_tree(branch):
            return False
    return True

def is_leaf(tree):
    return not branches(tree)

is_tree：定义怎么写，验证就怎么写

is_tree 是本讲第一个递归函数，而且它的结构逐字对应树的递归定义：「一棵树是一个列表，第 0 项是标签，其余各项都是树」。

is_tree([3, [1], [2, [1]]])
    type 是 list ✓，len = 3 ≥ 1 ✓
    branches = [[1], [2, [1]]]
    ├─ is_tree([1])
    │      type list ✓，len 1 ≥ 1 ✓
    │      branches = []  → for 循环体一次都不执行
    │      → return True                      ← base case（隐式的！）
    ├─ is_tree([2, [1]])
    │      type list ✓，len 2 ≥ 1 ✓
    │      branches = [[1]]
    │      └─ is_tree([1]) → True
    │      → return True
    → 两个分支都是树 → return True

is_tree([3, 1])
    type list ✓，len 2 ≥ 1 ✓
    branches = [1]
    └─ is_tree(1)
           type(1) != list → return False     ← 在这里判死
    not False 为真 → return False

两个细节：

• base case 藏在 for 循环里。is_tree 没有写 if is_leaf(tree): return True，因为叶子的 branches 是 []，for 循环体零次执行，直接落到最后一行 return True。「对空列表做循环 = 什么都不做」正是树递归能省掉 base case 的原因，这个模式在第 7 节还会再遇到三次。
• len(tree) < 1 这个检查不能省。空列表 [] 不是合法的树——树必须至少有一个标签。如果去掉这个检查，is_tree([]) 会返回 True，然后 label([]) 就会炸出 IndexError: list index out of range。实测：

>>> is_tree([])
False
>>> is_tree(3)
False
>>> is_tree([3, 1])
False
>>> is_tree([3, [1]])
True

is_leaf：为什么一个 not 就够了

is_leaf(tree) 的定义是「没有分支」，代码 return not branches(tree) 依赖 Python 的一条规则：空列表在布尔语境下是假值（falsy）。

>>> bool([])
False
>>> bool([[1]])
True
>>> is_leaf(tree(3))              # branches 是 []
True
>>> is_leaf(tree(3, [tree(1)]))   # branches 是 [[1]]
False

写成 return len(branches(tree)) == 0 或 return branches(tree) == [] 完全等价，只是啰嗦。但不要写成下面这些：

最后把这五个函数放在一起，这是本讲要背下来的全部接口：

6. 手写一棵树：怎么把图翻译成代码

考试和作业里最常见的一类小题是：给你一张树的图，写出构造它的表达式；或者给你一个表达式，画出树。这一节把这个来回走通。

从图到代码：从根开始，一层一层往里塞

目标是这棵树：

          5
        / | \
       1  3  2
       |  |
       0  4
          |
          6

写成一行读起来非常难受。课上给的建议是按分支换行对齐：

tree(5, [tree(1, [tree(0)]),
         tree(3, [tree(4, [tree(6)])]),
         tree(2)])

从代码到图：数括号不如数「参数位置」

反过来读表达式时，不要一个一个数括号。抓住一条规则：tree( 后面第一个逗号之前的东西是标签，方括号里逗号分隔的每一项是一个孩子。

验证一下上面那棵树的底层表示：

>>> t = tree(5, [tree(1, [tree(0)]), tree(3, [tree(4, [tree(6)])]), tree(2)])
>>> t
[5, [1, [0]], [3, [4, [6]]], [2]]

把这个列表和图对照：5 后面跟着三个东西，正好三个孩子；[1, [0]] 是「标签 1，一个孩子 0」；[2] 只有标签，是叶子。

一道随堂题

课上问过：已经定义好树 ADT，求值 tree(5, [1]) 会显示什么？

答案不是列表，是报错：AssertionError: branches must be trees。理由前面说过——1 不是树。如果构造器里没有那行 assert，它会安静地返回 [5, 1]，而这个东西 is_tree 判为 False，是个「伪树」，交给任何树函数都会在某个更深的地方崩掉。断言的价值就在这里：让错误在制造现场暴露，而不是在案发现场。

7. 树递归的通用形状

接下来四节全是练习，但它们其实是同一个模板的四次变奏。先把模板立起来，后面每道题只需要说清楚「它在哪个位置填了什么」。

def f(t):
    if is_leaf(t):              # ← 有时可省
        return <叶子的答案>
    else:
        sub = [f(b) for b in branches(t)]   # 每个分支的答案
        return <把 sub 和 label(t) 合成本层答案>

三个位置，每个位置的填法决定了这道题的全部：

为什么 base case 有时可以省

这是树递归和数字递归最不一样的地方，值得单独讲。看 double（第 10 节的答案）：

def double(t):
    new_branches = []
    for b in branches(t):
        new_branches.append(double(b))
    return tree(2 * label(t), new_branches)

它没有 base case，但不会无限递归。为什么？

double([3])
    new_branches = []
    branches([3]) 是 []
    for b in []:        ← 循环体一次都不执行，没有任何递归调用发生
    return tree(2 * 3, [])
         = tree(6, [])
         = [6]

换成列表推导式写法看得更清楚：[double(b) for b in branches(t)]，当 branches(t) 是 [] 时，这个表达式的值就是 []，里面一次 double 都没调用。

两种合并：sum 的两副面孔

本讲有两处用到 sum，它们做的事完全不同，别搞混：

sum(seq, start) 做的事是：从 start 开始，依次 + 上 seq 的每个元素。start 不写时默认是整数 0。所以拼列表时如果忘了写 []：

>>> sum([[1], [2, 3], [4]], [])
[1, 2, 3, 4]
>>> sum([[1], [2, 3], [4]])
TypeError: unsupported operand type(s) for +: 'int' and 'list'

报错说的是「int 加 list 不行」——那个 int 就是默认起点 0。看到这条报错，条件反射地去找漏写的 , []。

8. fib_tree：用递归造一棵树

前面的函数都是「拿到一棵树，算点什么」。这一节反过来：递归地造出一棵树。这是树 ADT 真正有意思的用法。

def fib_tree(n):
    """
    Returns a tree representation of the nth Fibonacci number
    """
    if n == 0 or n == 1:
        return tree(n)
    else:
        left, right = fib_tree(n - 2), fib_tree(n - 1)
        fib_n = label(left) + label(right)
        return tree(fib_n, [left, right])

逐行读

• if n == 0 or n == 1: return tree(n)——base case。斐波那契数列 fib(0) = 0、fib(1) = 1，两者都是「直接知道答案」，造一片叶子返回。注意返回的是 tree(n)（一棵树），不是 n（一个数）。
• left, right = fib_tree(n - 2), fib_tree(n - 1)——多重赋值。右边是一个元组表达式，整个右边先完全求值完，再一次性绑定左边两个名字。求值顺序是从左到右：先算完 fib_tree(n - 2)（造出一整棵树），再算 fib_tree(n - 1)。
• fib_n = label(left) + label(right)——这是全函数的精髓。本层的根标签不是靠公式算的，而是从两个已经造好的子树身上「读」出来的。label(left) 就是 fib(n-2)，label(right) 就是 fib(n-1)，相加正是 fib(n)。递归假设在这里被兑现：我不需要知道子树是怎么造的，我只需要相信它的根标签是对的。
• return tree(fib_n, [left, right])——用构造器把标签和两棵子树装成新树。注意 [left, right] 这个方括号：branches 参数必须是装着树的列表，而 left、right 本身已经是树了，所以直接装进去就行，不要再套一层 tree(...)。

真的展开一遍

fib_tree(3)
  n=3，不是 base case
  ├─ left  = fib_tree(1)
  │            n=1 → return tree(1) = [1]                  ← 触底
  ├─ right = fib_tree(2)
  │            n=2，不是 base case
  │            ├─ left  = fib_tree(0) → tree(0) = [0]      ← 触底
  │            ├─ right = fib_tree(1) → tree(1) = [1]      ← 触底
  │            ├─ fib_n = label([0]) + label([1]) = 0 + 1 = 1
  │            └─ return tree(1, [[0], [1]]) = [1, [0], [1]]
  ├─ fib_n = label([1]) + label([1, [0], [1]]) = 1 + 1 = 2
  └─ return tree(2, [[1], [1, [0], [1]]]) = [2, [1], [1, [0], [1]]]

>>> fib_tree(3)
[2, [1], [1, [0], [1]]]
>>> fib_tree(4)
[3, [1, [0], [1]], [2, [1], [1, [0], [1]]]]
>>> fib_tree(5)
[5, [2, [1], [1, [0], [1]]], [3, [1, [0], [1]], [2, [1], [1, [0], [1]]]]]

把 fib_tree(5) 画成图（左分支是 n-2，右分支是 n-1）：

                       5
                 /            \
                2              3
              /   \          /    \
             1     1        1      2
                  / \      / \    /  \
                 0   1    0   1  1    1
                                     / \
                                    0   1

数一数叶子：1、0、1、0、1、1、0、1——8 片。而 8 正好是 fib(6)。这不是巧合：

>>> [count_leaves(fib_tree(n)) for n in range(9)]
[1, 1, 2, 3, 5, 8, 13, 21, 34]

课上还提到可以把这段代码贴到 code.cs61a.org，用 autodraw() 把 fib_tree(5) 直接画出来。自学时强烈建议做一次——把上面那张手画的图和工具画的图对照，能一次性确认你对「哪边是左分支」的理解是对的。

9. count_leaves 与 leaves：把一棵树折成一个答案

这两个函数是一对：一个数叶子有几片，一个把叶子的标签收集成列表。它们的骨架一模一样，只有「合并方式」不同，正好用来体会第 7 节那张表。

count_leaves

def count_leaves(t):
    """Returns the number of leaves in the tree t"""
    if is_leaf(t):
        return 1
    else:
        branch_counts = [count_leaves(b) for b in branches(t)]
        return sum(branch_counts)

读法：「一棵树的叶子数 = 它各个分支的叶子数之和；除非它本身就是叶子，那就是 1。」这句话几乎是代码的逐字翻译。

          3
         / \
        1   2
           / \
          1   1

count_leaves([3, [1], [2, [1], [1]]])
    is_leaf? branches = [[1], [2,[1],[1]]] 非空 → 否
    branch_counts = [ count_leaves([1]),  count_leaves([2,[1],[1]]) ]
                      │                    │
                      │                    ├─ is_leaf? 否
                      │                    ├─ branch_counts = [count_leaves([1]), count_leaves([1])]
                      │                    │                   = [1, 1]
                      │                    └─ return sum([1,1]) = 2
                      └─ is_leaf? branches = [] → 是 → return 1
    branch_counts = [1, 2]
    return sum([1, 2]) = 3

这里的 base case 必须写。原因在第 7 节说过：叶子应该返回 1，但如果省掉 base case，叶子会走到 sum([])，得到 0——整个函数会对任何树都返回 0。这是个典型的不报错但全错的 bug，比崩溃更难查。

leaves：收集标签

def leaves(t):
    """
    Return a list of all the leaf labels of the tree `t`
    >>> leaves(tree(2))
    [2]
    >>> leaves(tree(3, [tree(1), tree(2)]))
    [1, 2]
    >>> leaves(tree(5, [tree(1, [tree(0)]), tree(3, [tree(4, [tree(6)])]), tree(2)]))
    [0, 6, 2]
    """
    if is_leaf(t):
        return [label(t)]
    else:
        return sum([leaves(b) for b in branches(t)], [])

怎么想到的

第一个 doctest 就把两件事定死了：leaves(tree(2)) 返回 [2] 而不是 2。所以：

leaves([5, [1,[0]], [3,[4,[6]]], [2]])
  不是叶子，三个分支
  ├─ leaves([1, [0]])
  │     不是叶子（branches = [[0]]）
  │     └─ leaves([0]) → 是叶子 → return [0]
  │     sum([ [0] ], []) = [0]
  ├─ leaves([3, [4, [6]]])
  │     不是叶子
  │     └─ leaves([4, [6]])
  │           不是叶子
  │           └─ leaves([6]) → 是叶子 → return [6]
  │           sum([ [6] ], []) = [6]
  │     sum([ [6] ], []) = [6]
  └─ leaves([2]) → 是叶子 → return [2]

  内层结果列表 = [ [0], [6], [2] ]
  sum([ [0], [6], [2] ], []) = [] + [0] + [6] + [2] = [0, 6, 2]  ✓

注意结果的顺序：[0, 6, 2] 而不是 [0, 2, 6]。顺序完全由 branches(t) 的顺序决定——列表推导式从左到右遍历分支，sum 从左到右拼接。这叫深度优先、从左到右的遍历顺序，是本课程所有树函数的默认行为。

>>> leaves(tree(3, [tree(1), tree(2)]))
TypeError: can only concatenate list (not "int") to list

>>> leaves(tree(3, [tree(1), tree(2)]))
TypeError: unsupported operand type(s) for +: 'int' and 'list'

def leaves(t):
    if is_leaf(t):
        return [label(t)]
    result = []
    for b in branches(t):
        result += leaves(b)     # 或 result.extend(leaves(b))
    return result

>>> leaves(tree(5, [tree(1, [tree(0)]), tree(3, [tree(4, [tree(6)])]), tree(2)]))
[[[0]], [[[6]]], [2]]

10. double：造出一棵新树

前两个函数把树折成一个数或一个列表。double 是另一类：输入一棵树，输出一棵树——把每个节点的标签翻倍。

def double(t):
    """
    Return a new tree ADT which is the result of
    doubling the labels of every node in the original tree `t`.
    >>> double(tree(1)) == tree(2)
    True
    >>> double(tree(3, [tree(1), tree(2)])) == tree(6, [tree(2), tree(4)])
    True
    """
    new_branches = []
    for b in branches(t):
        new_branches.append(double(b))
    return tree(2 * label(t), new_branches)

怎么想到的

先读 doctest。double(tree(1)) == tree(2)——注意这里用的是 ==，而 doctest 期望 True。这说明：

• 返回值必须是一棵结构完全相同、标签全部翻倍的树。因为树的底层是列表，== 会逐元素递归比较，所以 [2] == [2] 为真。
• doctest 没有要求返回的是同一个对象（那要用 is），但函数名叫「return a new tree」，说明不该原地修改 t。

接着套第 7 节的模板。这一层要产出的是「一棵树」，而造树只能用构造器 tree(标签, 分支列表)，所以问题变成两个：

课上给的写法用了显式循环 + append，和列表推导式完全等价：

# 官方解答里给出的等价写法一：列表推导式
return tree(label(t) * 2, [double(b) for b in branches(t)])

注意这里的 append 是正确的（和上一节 leaves 里的错误用法形成对照）：因为 double(b) 返回的是一棵树，而 new_branches 要装的正是一棵一棵的树，所以「整个塞进去」才对。上一节 leaves 里 leaves(b) 返回的是一列标签，而我们要的也是一列标签，所以必须摊开。区别在于「递归返回的东西」和「我要装的东西」层级是否一致。

为什么不需要 base case

官方解答还给了第三种写法，并且注明了它的缺点：

# 官方解答里给出的等价写法二：显式 base case
# 缺点：重复代码（标签翻倍写了两遍）
if is_leaf(t):
    return tree(label(t) * 2)
else:
    return tree(label(t) * 2, [double(b) for b in branches(t)])

这个版本没错，只是啰嗦。因为 tree(x) 和 tree(x, []) 是同一回事（默认参数就是 []），而叶子的 [double(b) for b in branches(t)] 恰好就求值成 []。两条分支合并成一条即可。

double([3, [1], [2]])
    new_branches = []
    branches = [[1], [2]]
    ├─ b = [1]
    │     double([1])
    │         new_branches = []
    │         branches([1]) = []  → for 循环零次
    │         return tree(2 * 1, []) = [2]
    │     new_branches = [[2]]
    └─ b = [2]
          double([2])
              branches([2]) = [] → for 循环零次
              return tree(2 * 2, []) = [4]
          new_branches = [[2], [4]]
    return tree(2 * 3, [[2], [4]])
         = tree(6, [[2], [4]])
         = [6, [2], [4]]

比较：tree(6, [tree(2), tree(4)]) = [6, [2], [4]]
[6, [2], [4]] == [6, [2], [4]]  →  True  ✓

再看一个大一点的，能看出「结构不变、只有标签变」：

>>> t = tree(5, [tree(1, [tree(0)]), tree(3, [tree(4, [tree(6)])]), tree(2)])
>>> t
[5, [1, [0]], [3, [4, [6]]], [2]]
>>> double(t)
[10, [2, [0]], [6, [8, [12]]], [4]]
>>> t
[5, [1, [0]], [3, [4, [6]]], [2]]

最后一行是关键：t 一点没变。因为 double 从头到尾没有对 t 或它的任何子列表做过变异操作，它只是读（label、branches）和造新的（tree）。这就是「不可变风格」的写法，也是本课程处理树的默认姿势。

def double(t):
    t[0] = t[0] * 2                 # 越过屏障 + 原地变异
    for b in branches(t):
        double(b)
    return t

11. count_paths：让信息往下走

前面所有函数的信息流向都是从下往上：子树算完，把答案交给父节点合并。count_paths 引入一个新东西——还需要把信息从上往下传。这是树递归里难度上一个台阶的地方，也是考试爱考的地方。

def count_paths(t, total):
    """
    Return the number of paths from the root node to any other node in the tree
    that adds up to the target total.
    >>> t = tree(3, [tree(-1), tree(1, [tree(2, [tree(1)]), tree(3)]), tree(1, [tree(-1)])])
    >>> count_paths(t, 3)  # path does not have to go to a leaf
    2
    >>> count_paths(t, 4)
    2
    >>> count_paths(t, 5)
    0
    >>> count_paths(t, 6)
    1
    >>> count_paths(t, 7)
    2
    """

题目到底要什么

写成文本树：

t = tree(3, [tree(-1),
             tree(1, [tree(2, [tree(1)]), tree(3)]),
             tree(1, [tree(-1)])])

                3
             /  |  \
           -1   1    1
               / \    \
              2   3    -1
              |
              1

docstring 说的是「从根节点到任意其它节点的路径」，而 count_paths(t, 3) 那行的注释又补了一句「path does not have to go to a leaf」（路径不必走到叶子）。把两条合起来，再对着答案反推，规则是：

为什么能确定包含「只有根」这条？因为 count_paths(t, 3) 的答案是 2。把所有从根出发的路径穷举出来：

数一数：和为 3 的有 2 条（「只有根」和「右支 3→1→-1」）→ count_paths(t, 3) == 2 ✓。和为 4 的有 2 条 ✓。和为 5 的 0 条 ✓。和为 6 的 1 条 ✓。和为 7 的 2 条 ✓。如果不算「只有根」那条，count_paths(t, 3) 就只有 1，doctest 会挂。这就是「读 doctest」的实际含义——它把定义里含糊的地方钉死了。

怎么想到的：把「已经走了多少」变成「还差多少」

第一反应通常是：「往下递归的时候，得知道从根到现在累加了多少。」于是想给函数加一个参数 so_far。但函数签名是题目给死的 count_paths(t, total)，只有两个参数，不能加。

关键的一步转念：与其往下传「已经攒了多少」，不如往下传「还差多少」。这两者是等价的信息，但后者能复用同一个参数位。

剩下的就是本层要不要计数：如果 label(t) == total，说明「从当前根出发、只取根这一个节点」就正好凑够了，这是一条合法路径，计 1。

代码

def count_paths(t, total):
    if label(t) == total:
        found = 1
    else:
        found = 0
    return found + sum([count_paths(b, total - label(t)) for b in branches(t)])

逐行：

• if label(t) == total: found = 1——本层自己贡献的路径数（0 或 1）。注意找到之后不能 return：即使当前节点正好凑够，它的子孙里可能还有别的路径（比如再走一个 +2 一个 -2）。所以要继续往下找。
• total - label(t)——往下传的新目标。这是全题的核心，写成 total 就全错（见下）。
• sum([...])——各分支找到的路径数相加。这里不需要 base case：叶子的 branches 是 []，sum([]) 是 0，函数直接返回 found，正确。

验证：完整展开 count_paths(t, 7)

count_paths([3, [-1], [1,[2,[1]],[3]], [1,[-1]]], 7)
  label = 3，3 != 7 → found = 0
  往下传的目标：7 - 3 = 4
  │
  ├─ count_paths([-1], 4)
  │     label = -1 != 4 → found = 0
  │     branches = [] → sum([]) = 0
  │     → 0
  │
  ├─ count_paths([1, [2,[1]], [3]], 4)
  │     label = 1 != 4 → found = 0
  │     往下传：4 - 1 = 3
  │     ├─ count_paths([2, [1]], 3)
  │     │     label = 2 != 3 → found = 0
  │     │     往下传：3 - 2 = 1
  │     │     └─ count_paths([1], 1)
  │     │           label = 1 == 1 → found = 1        ← 命中！路径 3→1→2→1
  │     │           branches = [] → 0
  │     │           → 1
  │     │     → 0 + 1 = 1
  │     └─ count_paths([3], 3)
  │           label = 3 == 3 → found = 1              ← 命中！路径 3→1→3
  │           branches = [] → 0
  │           → 1
  │     → 0 + sum([1, 1]) = 2
  │
  └─ count_paths([1, [-1]], 4)
        label = 1 != 4 → found = 0
        往下传：4 - 1 = 3
        └─ count_paths([-1], 3)
              label = -1 != 3 → found = 0
              → 0
        → 0 + 0 = 0

  → 0 + sum([0, 2, 0]) = 2   ✓

展开对上了表格里「和为 7 的两条路径」：3→1→2→1 和 3→1→3。

再快速看 count_paths(t, 3) 的两次命中在哪：

count_paths(t, 3)
  label = 3 == 3 → found = 1                    ← 命中 1：路径「只有根」
  往下传：3 - 3 = 0
  ├─ count_paths([-1], 0)          -1 != 0 → 0
  ├─ count_paths([1, ...], 0)      1 != 0，往下传 0-1 = -1
  │     ├─ count_paths([2,[1]], -1)   2 != -1，往下传 -1-2 = -3
  │     │     └─ count_paths([1], -3) → 0
  │     │     → 0
  │     └─ count_paths([3], -1)  → 0
  │     → 0
  └─ count_paths([1, [-1]], 0)     1 != 0，往下传 0-1 = -1
        └─ count_paths([-1], -1)   -1 == -1 → 1    ← 命中 2：路径 3→1→-1
        → 1
  → 1 + sum([0, 0, 1]) = 2   ✓

注意目标值一路变成了负数，这完全正常——total 只是个数字，没有「必须为正」的约束。不要自作聪明加 if total < 0: return 0 的剪枝，因为标签可以是负数，往下走还可能加回来（右支的 -1 就是靠这个被找到的）。

>>> [count_paths(t, x) for x in range(3, 8)]   # 错误版本
[2, 0, 0, 0, 0]
>>> [count_paths(t, x) for x in range(3, 8)]   # 正确版本
[2, 2, 0, 1, 2]

if label(t) == total:
    return 1                      # ← 错：不再往下找了
return sum([count_paths(b, total - label(t)) for b in branches(t)])

本讲小结

树 ADT 速查

四类树函数，四种合并方式

报错速查

三条要记住的话

动手练习

建议先关掉答案自己做，做完再对。全部代码可以直接贴进 09.py 跑。

练习 1：WWPD（What Would Python Display）

设 t = tree(1, [tree(2, [tree(3)]), tree(4)])。下面每行分别显示什么？

>>> t
>>> label(branches(t)[0])
>>> is_leaf(branches(t)[1])
>>> branches(branches(t)[0])[0]
>>> label(t) + label(branches(t)[1])
>>> tree(1, [2])

>>> t
[1, [2, [3]], [4]]
>>> label(branches(t)[0])
2
>>> is_leaf(branches(t)[1])
True
>>> branches(branches(t)[0])[0]
[3]
>>> label(t) + label(branches(t)[1])
5
>>> tree(1, [2])
AssertionError: branches must be trees

练习 2：count_nodes

写 count_nodes(t)，返回树 t 里节点的总数（包括根和所有内部节点，不只是叶子）。要求不写显式 base case，并说明为什么可以不写。

>>> count_nodes(tree(1, [tree(2, [tree(3)]), tree(4)]))
4
>>> count_nodes(tree(5, [tree(1, [tree(0)]), tree(3, [tree(4, [tree(6)])]), tree(2)]))
7
>>> count_nodes(tree(9))
1

def count_nodes(t):
    return 1 + sum([count_nodes(b) for b in branches(t)])

count_nodes([1, [2,[3]], [4]])
  = 1 + sum([ count_nodes([2,[3]]),  count_nodes([4]) ])
                │                      │
                │                      └─ 1 + sum([]) = 1
                └─ 1 + sum([ count_nodes([3]) ])
                         └─ 1 + sum([]) = 1
                   = 1 + 1 = 2
  = 1 + sum([2, 1]) = 1 + 3 = 4  ✓

练习 3：max_label

写 max_label(t)，返回树 t 中所有标签的最大值。标签可以是负数。

>>> max_label(tree(1, [tree(2, [tree(3)]), tree(4)]))
4
>>> max_label(tree(3, [tree(9), tree(2, [tree(-1)])]))
9
>>> max_label(tree(7))
7

# 写法一：显式 base case
def max_label(t):
    if is_leaf(t):
        return label(t)
    return max([label(t)] + [max_label(b) for b in branches(t)])

# 写法二：不写 base case
def max_label(t):
    return max([label(t)] + [max_label(b) for b in branches(t)])

练习 4：找 bug

下面三个 leaves 的实现各有一处错。分别说出：错在哪、跑起来是什么现象（报什么错，或者输出什么）。测试用 t = tree(3, [tree(1), tree(2)])，正确答案是 [1, 2]。

# A
def leaves(t):
    if is_leaf(t):
        return label(t)
    return sum([leaves(b) for b in branches(t)], [])

# B
def leaves(t):
    if is_leaf(t):
        return [label(t)]
    return sum([leaves(b) for b in branches(t)])

# C
def leaves(t):
    if is_leaf(t):
        return [label(t)]
    return [leaves(b) for b in branches(t)]

TypeError: can only concatenate list (not "int") to list

TypeError: unsupported operand type(s) for +: 'int' and 'list'

>>> leaves(tree(3, [tree(1), tree(2)]))
[[1], [2]]

练习 5：print_tree

写 print_tree(t, indent=0)，按层级缩进打印整棵树，每层缩进两个空格。这道题练的是第 11 节那个「把上下文往下传」的套路。

>>> print_tree(tree(5, [tree(1, [tree(0)]), tree(3, [tree(4, [tree(6)])]), tree(2)]))
5
  1
    0
  3
    4
      6
  2

def print_tree(t, indent=0):
    print('  ' * indent + str(label(t)))
    for b in branches(t):
        print_tree(b, indent + 1)