可变树：把树从「一串列表」升级成对象

0. 本讲导读

这一讲夹在两大块之间，所以它看上去有点「杂」：前半截还在收拾面向对象（object-oriented programming）的尾巴——继承下的属性查找、自己实现迭代器、自己定义异常类；后半截才进入正题——可变树（mutable tree）。

但这两半其实是同一件事的两面。前半截讲的是「一个类怎么参与 Python 已有的机制」：实现 __iter__ / __next__，你的对象就能被 for 循环吃进去；继承 Exception，你的类就能被 raise 抛出、被 except 接住。后半截讲的是「把一个我们已经很熟的数据结构改写成类之后，什么变了、什么没变」。

说说「什么变了」。第 8 讲你学过 tree ADT：

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

一棵树就是一个列表，第 0 个元素是根标签，剩下的元素是各个分支。这套写法的好处是不需要 class 就能用；坏处是你没法优雅地改一棵树。想把某个节点的标签从 3 改成 99，你得写 t[0] = 99——这一行直接捅穿了抽象屏障（abstraction barrier），因为它假定「树就是列表」。想给某个节点添一个分支？t.append(new_branch)，同样是在操作列表而不是在操作树。ADT 层只给了你 tree / label / branches 三个函数，其中没有一个是「修改器（mutator）」。

把树写成类之后，节点的标签就是一个实例属性（instance attribute） t.label，分支列表就是 t.branches。改标签是 t.label = 99，加分支是 t.branches.append(...)——这两句既符合抽象（读起来就是「改这棵树的标签」），又真的把对象改掉了。这就是「mutable trees」这个标题的意思：树第一次可以被就地修改。

再说说「什么没变」：递归的写法一点没变。 这一讲最重要的一张对照图，就是同一个 fib_tree 用 ADT 和用类各写一遍——两边的结构完全一样，只有 label(t) 变成 t.label、tree(...) 变成 Tree(...)。树上的递归骨架（对每个 branch 递归、在 leaf 处停）与树的表示方式无关。这句话你现在可能觉得平淡，等到写 height、reveal_winner 的时候会反复用到。

本讲的三道练习题（height、TreeIterator、reveal_winner）都来自随堂代码 15.py，其中最后一道是本学期期中考试第 6 题 Bracket Breaker 的 Tree 类版本。三道题分别练三种能力：树上的普通递归、用队列做层序遍历（顺带把迭代器落到实处）、以及「递归返回一对值」这种高级套路 + 生成器。

1. 热身：继承下的属性查找（WWPD）

上一讲讲了继承和 super()，这一讲开头用一道 What Would Python Display 把它钉死。题目的两个类：

class A:
    foo = 0

    def __init__(self, foo, bar):
        self.foo = foo + A.foo
        A.foo += 1
        self.bar = bar

class B(A):
    foo = 5

    def __init__(self, bar):
        super().__init__(B.foo, bar)

做这类题只需要一条铁律，但必须一字不差地执行：

注意 __init__ 里那三行的微妙之处：self.foo = foo + A.foo 右边的 A.foo 是类属性（从 A 查），左边的 self.foo 是实例属性（写到实例上）。然后 A.foo += 1 展开是 A.foo = A.foo + 1，读的是类属性、写的也是类属性——所以每 new 一次 A，类属性 A.foo 就涨 1。这是一个计数器。

第一次调用

>>> first = A(2, 3)
>>> first.foo
2
>>> first.bar
3
>>> A.foo
1

class A            类属性 foo ──→ 1        (被 A.foo += 1 改过)
class B(A)         类属性 foo ──→ 5        (从没被改过)

first (an A)       实例属性 foo ──→ 2
                   实例属性 bar ──→ 3

第二次调用：计数器在涨

>>> second = A(2, 3)
>>> second.foo
3
>>> second.bar
3
>>> A.foo
2

同样的实参 A(2, 3)，second.foo 却是 3 而不是 2。原因在第 2 步：这一次 A.foo 已经是 1 了，所以 2 + 1 = 3。然后 A.foo 再涨到 2。类属性是所有实例共享的一块状态，改它就是在改一个全局计数器。

第三次调用：轮到子类 B

>>> third = B(2, 3)
Error

先解决这个「Error」。B.__init__ 的签名是 def __init__(self, bar)，只收一个参数。B(2, 3) 想传两个，参数个数对不上。真实报错是：

Traceback (most recent call last):
  ...
TypeError: B.__init__() takes 2 positional arguments but 3 were given

「takes 2 ... but 3 were given」里的 2 和 3 都把 self 算进去了：B.__init__ 声明了 self 和 bar 共 2 个，而 B(2, 3) 实际传的是「新实例 + 2 + 3」共 3 个。看到这类报错，先在心里把 self 补回去再数。

改成正确的调用：

>>> third = B(3)
>>> third.foo
7
>>> third.bar
3
>>> B.foo
5
>>> A.foo
3

最后两行是这道题的题眼：

>>> third.foo = 100
>>> third.foo
100
>>> B.foo
5

third.foo = 100 只在这一个实例上写了个 foo。类属性 B.foo 完全不知情，还是 5。反过来说，如果这时候你新建一个 B(0)，它的 foo 会重新按公式算，跟 100 没有半点关系。

2. 自己写一个迭代器：__iter__ 与 __next__

第 12 讲你学过怎么用迭代器：iter(x) 拿到一个迭代器，next(it) 一个一个往外取，取完了抛 StopIteration。for 循环、list()、列表推导式在底层做的都是这套动作。

现在反过来问：要让「我自己写的类」也能被 for 循环吃进去，需要满足什么条件？答案很短——实现两个特殊方法：

课上的例子是一个产出偶数的迭代器：

class Evens:
    """Iterator that returns positive even numbers <= n"""
    def __init__(self, n: int):
        self.curr = 0
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.curr <= self.n:
            temp = self.curr
            self.curr += 2
            return temp
        else:
            raise StopIteration

__next__ 里那三行为什么是这个顺序

temp = self.curr      # 1. 记住"这次该返回的值"
self.curr += 2        # 2. 把进度推到下一格
return temp           # 3. 返回记住的那个值

对应的交互记录：

>>> evens = Evens(5)
>>> evens_iter = iter(evens)
>>> next(evens_iter)
0
>>> next(evens_iter)
2
>>> next(evens_iter)
4
>>> next(evens_iter)
Traceback (most recent call last):
  ...
StopIteration

如果不用 temp，两种「简化」都会错：

TypeError: 'NoIter' object is not iterable

TypeError: 'NoNext' object is not an iterator

>>> e = Evens(5)
>>> [x for x in e]
[0, 2, 4]
>>> [x for x in e]
[]

另外，Evens 的 docstring 写的是 "positive even numbers"，但它实际会先吐一个 0，而 0 不是正数。这是讲义代码里的一处小瑕疵，不影响理解，但提醒你一件事：docstring 是人写的，doctest 才是机器验证过的。两者打架时，以 doctest 为准。

3. 自定义异常类与特殊方法一览

第 1 讲讲过 try / except / raise，当时抛的都是 Python 内置的异常，比如 ZeroDivisionError、AssertionError。现在你会写类了，就可以造自己的异常类型。

做法只有一句话：继承 Exception。为什么必须继承？因为 raise 只接受 BaseException 的子类，而 except SomeError 用的判断也是 isinstance——继承关系正是 except 能不能接住的依据。

课上的例子给 Account 加了「余额不足」这种情况：

class Account:
    interest = 0.02

    def __init__(self, account_holder):
        self.balance = 0
        self.holder = account_holder

    def deposit(self, amount):
        self.balance = self.balance + amount
        return self.balance

    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientFundsException(amount, self.balance)
        self.balance = self.balance - amount
        return self.balance

class InsufficientFundsException(Exception):
    def __init__(self, amount, balance):
        message = f'Requested ${amount} is larger than current balance ${balance}'
        super().__init__(message)

        self.amount = amount
        self.balance = balance

为什么要挂 self.amount 和 self.balance

关键在使用现场：

>>> acct = Account('Jane')
>>> acct.deposit(15)
15
>>> try:
...     acct.withdraw(20)
... except InsufficientFundsException as ex:
...     print(f'You need ${ex.amount - ex.balance} more')
...
You need $5 more

第 5 步是整个设计的意义所在。如果异常只带一句字符串，处理方想知道「还差多少钱」就得去解析那句英文——脆弱、恶心、而且一改文案就崩。把数据以属性形式挂在异常对象上，处理方就能直接算。异常对象是一个普通对象，你可以往上挂任何东西。

如果没人接住它，traceback 里显示的是父类保管的那句 message：

Traceback (most recent call last):
  ...
InsufficientFundsException: Requested $20 is larger than current balance $15

目前为止该掌握的特殊方法

Python 的特殊方法远不止这些（__len__、__getitem__、__add__……），这门课不要求全会。但要记住这套机制的名字叫 dunder（double underscore）方法，以及它的共同逻辑：你不直接调用它们，是 Python 的某个内置语法或内置函数替你调用的。写 len(x) 而不是 x.__len__()，写 print(x) 而不是 x.__str__()——这是约定，也是让你的类能无缝接入语言其余部分的接口。

4. 回顾：树的 ADT 表示，以及它卡在哪儿

先把旧的写法完整摆出来。一棵树由一个根标签（root label）和一个分支（branches）列表构成，每个分支自己也是一棵树——这是一个递归定义，也是树上所有算法都能写成递归的根本原因。

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:]

加上两个判断函数：

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)

三点值得重看：

• tree(...) 里那句 assert 是构造时的校验：只要你老老实实用 tree 造树，造出来的东西一定合法，后面所有函数都可以放心假设「传进来的是棵树」。
• [root_label] + list(branches) 里的 list(...) 做了一次浅拷贝，并且 + 本身就会产生一个新列表。所以调用方后来往自己那个 branches 列表里塞东西，不会影响已经造好的树。
• is_leaf 的判据是「没有分支」，不是「标签是某个特殊值」，也不是「深度到底了」。叶子（leaf）= branches 为空。

def f(t):
    if is_leaf(t):          # 或者别的终止条件
        return <基本情况的答案>
    return <把 [f(b) for b in branches(t)] 和 label(t) 合起来>

ADT 表示卡在哪儿

它其实很好用，缺点只有在你想修改一棵树的时候才暴露。假设有 t = tree(3, [tree(2, [tree(5)]), tree(4)])，也就是列表 [3, [2, [5]], [4]]。现在要把根标签改成 99：

>>> t[0] = 99

这一行捅穿了抽象屏障。它没有用任何一个 ADT 函数，而是直接利用了「树恰好是用列表实现的」这个事实。第 8 讲反复强调过：一旦有代码这么写，你就再也不能换实现了——哪天想改成用字典或者对象表示树，这一行就会静默地做错事或崩掉。

问题在于，ADT 层根本没提供修改的手段。tree 是构造器，label / branches 是选择器，没有修改器（mutator）。想「改一棵树」，函数式的正统做法是造一棵新树：

>>> t2 = tree(99, branches(t))     # 造新的，原来的 t 不动

这条路完全走得通（本讲最后那道 reveal_winner 用的就是这个思路），但对于「只想改一个节点」的场景，你得把从根到那个节点的整条路径上的树全部重建一遍。代码会很啰嗦。

还有个更日常的痛点：branches(t) 每次都返回 tree[1:]，这是一个新的切片列表。所以下面这行看起来在加分支，其实什么也没发生：

>>> branches(t).append(tree(7))    # 改的是切片产生的临时列表，t 完全没变

这是一个非常隐蔽的 bug：没有报错，没有异常，就是不生效。把树换成类，正是为了让「改一个节点」这件事既合法又直观。

5. Tree 类：把树做成对象

同一种数据，换一种表示：

class Tree:
    def __init__(self, label, branches=[]):
        self.label = label
        for branch in branches:
            assert isinstance(branch, Tree)
        self.branches = list(branches)

    def is_leaf(self):
        return not self.branches

逐行对照一下，你会发现这不是「新东西」，是同一套概念换了个住处：

课上的验证：

>>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
>>> t.label
3
>>> t.branches[0].label
2
>>> t.branches[1].is_leaf()
True

这三行值得慢放，因为求值顺序在这里是有意义的。

Global frame
    t ──→ @3

@3  Tree instance          @2  Tree instance          @5  Tree instance
    label    ──→ 3             label    ──→ 2             label    ──→ 5
    branches ──→ [@2, @4]      branches ──→ [@5]          branches ──→ []

                           @4  Tree instance
                               label    ──→ 4
                               branches ──→ []

照着这张图读 t.branches[0].label：t 是 @3 → 取它的 branches，是列表 [@2, @4] → 取下标 0，是 @2 → 取 @2 的 label，是 2。点号从左往右一步一步走，每一步的中间结果都是一个具体的对象。而 t.branches[1].is_leaf() 走到 @4，调它的方法：@4.branches 是 []，not [] 为 True。

为什么 __init__ 里要写 list(branches)

这行小小的 list(...) 干了两件事，都很关键。

第一，它切断了与调用方那个列表的别名。如果写成 self.branches = branches：

>>> bs = [Tree(2)]
>>> t = Tree(1, bs)
>>> bs.append(Tree(3))      # 调用方往自己的列表里加东西
>>> t.branches              # 如果没有 list(...)，t 会莫名其妙多出一个分支

有了 list(...)，实际结果是 t 依然只有一个分支——它持有的是自己的那份列表：

>>> repr(t)
'Tree(1, [Tree(2)])'
>>> len(bs)
2

第二，它解掉了「可变默认参数」这个经典陷阱。def __init__(self, label, branches=[]) 里的那个 [] 是在定义函数时求值一次的，之后所有用默认值的调用共享同一个列表对象。假如写成 self.branches = branches，就会出这种事：

>>> a1 = Tree(1)            # 用默认的 []
>>> a2 = Tree(2)            # 也用默认的 []，是同一个列表！
>>> a1.branches.append(Tree(9))
>>> a2.branches             # 会变成 [Tree(9)] —— a2 凭空长出一个分支

因为有 list(branches)，每个实例拿到的都是那个共享默认列表的一份新拷贝，所以真实结果是各管各的：

>>> a1 = Tree(1)
>>> a2 = Tree(2)
>>> a1.branches.append(Tree(9))
>>> repr(a1), repr(a2)
('Tree(1, [Tree(9)])', 'Tree(2)')

>>> Tree(1, Tree(2))
Traceback (most recent call last):
  ...
TypeError: 'Tree' object is not iterable

>>> Tree(1, [2, 3])
Traceback (most recent call last):
  ...
AssertionError

6. 同一段递归的两种写法：fib_tree 对照

这一节只有一个目的：让你相信换表示不改算法。fib_tree(n) 造一棵「斐波那契树」——根标签是 \(\mathrm{Fib}(n)\)，左子树是 fib_tree(n-2)，右子树是 fib_tree(n-1)。两版代码并排：

# tree ADT 版
def fib_tree(n):
    if n == 0 or n == 1:
        return tree(n)
    else:
        left = fib_tree(n - 2)
        right = fib_tree(n - 1)
        fib_n = label(left) + label(right)
        return tree(fib_n, [left, right])

# Tree 类版
def fib_tree(n):
    if n == 0 or n == 1:
        return Tree(n)
    else:
        left = fib_tree(n - 2)
        right = fib_tree(n - 1)
        fib_n = left.label + right.label
        return Tree(fib_n, [left, right])

这里最容易被略过的一句是 fib_n = left.label + right.label。它体现了树递归的一个重要习惯：不要为了算根标签而再递归一次。两棵子树已经造好了，它们的根标签就是 \(\mathrm{Fib}(n-2)\) 和 \(\mathrm{Fib}(n-1)\)，直接读出来相加即可。如果写成 fib_n = fib(n-2) + fib(n-1)，等于把整个斐波那契又算了一遍，纯属浪费。

fib_tree(4)
├─ left  = fib_tree(2)
│         ├─ left  = fib_tree(0) → n==0，base case → Tree(0)
│         ├─ right = fib_tree(1) → n==1，base case → Tree(1)
│         └─ fib_n = 0 + 1 = 1   → Tree(1, [Tree(0), Tree(1)])
├─ right = fib_tree(3)
│         ├─ left  = fib_tree(1) → base case → Tree(1)
│         ├─ right = fib_tree(2)
│         │         ├─ left  = fib_tree(0) → Tree(0)
│         │         ├─ right = fib_tree(1) → Tree(1)
│         │         └─ fib_n = 0 + 1 = 1 → Tree(1, [Tree(0), Tree(1)])
│         └─ fib_n = 1 + 1 = 2   → Tree(2, [Tree(1), Tree(1, [Tree(0), Tree(1)])])
└─ fib_n = 1 + 2 = 3

Tree(3, [Tree(1, [Tree(0), Tree(1)]),
         Tree(2, [Tree(1), Tree(1, [Tree(0), Tree(1)])])])

注意 fib_tree(2) 被算了两次（一次作为 fib_tree(4) 的左子树，一次作为 fib_tree(3) 的右子树），而且两次造出来的是两个不同的对象——递归每次都在 Tree(...) 里新建实例，不会复用。所以这棵树里没有任何共享节点，你可以放心地修改其中任何一处而不担心波及别处。这个性质在下一节会变成关键。

7. 让树能被打印出来：__repr__、__str__ 与 indented

课上的 Tree 只写了 __init__ 和 is_leaf，但随堂代码 15.py 里的完整版本还带着三个跟显示有关的方法。它们是上一讲「字符串表示」的直接应用，而且后面那道 reveal_winner 的 doctest 就是靠它们才能对得上。

    def __repr__(self):
        if self.branches:
            branch_str = ', ' + repr(self.branches)
        else:
            branch_str = ''
        return 'Tree({0}{1})'.format(repr(self.label), branch_str)

    def __str__(self):
        return '\n'.join(self.indented())

    def indented(self):
        lines = []
        for b in self.branches:
            for line in b.indented():
                lines.append('  ' + line)
        return [str(self.label)] + lines

__repr__：造一段能粘回代码里的文本

repr 的目标是「程序员看的表示，最好能重建这个对象」。所以它拼出来的正是构造这棵树的那句代码：

>>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
>>> t
Tree(3, [Tree(2, [Tree(5)]), Tree(4)])

它的递归藏得很深，值得指出来：repr(self.branches) 是对一个列表调 repr，而列表的 repr 会对它的每个元素调 repr——那些元素是 Tree，于是又回到这个方法。递归就是这么接上的，代码里根本看不见显式的自调用。

那个 if self.branches: 是为了叶子好看：叶子没有分支，就不打印后面的空列表，输出 Tree(5) 而不是 Tree(5, [])。另外 repr(self.label) 而不是 str(self.label)——这样字符串标签会带上引号，Tree('W') 才是能粘回去执行的代码。

indented：把一棵树摊成缩进的若干行

这是本讲最漂亮的一段递归，因为它返回的是一个字符串列表，不是一个字符串——这样才能给每一行统一加缩进。

>>> print(t)
3
  2
    5
  4

关键在第 4 步：缩进是在「回代」的路上一层层叠加的。一个节点在整棵树里有多深，它的那一行就被路过的祖先加了多少次两个空格。这比「递归时传一个 depth 参数下去」更省事，也更能体现递归的本质——每一层只管把子层的结果整体往里推两格。

拿它看 fib_tree(4) 会很直观：

>>> print(fib_tree(4))
3
  1
    0
    1
  2
    1
    1
      0
      1

8. 可变性：现在树真的能改了

这才是标题里「Mutable Trees」的正题。Tree 实例是可变对象：它的 label 是一个可以重新绑定的实例属性，它的 branches 是一个货真价实的列表。

两种修改，性质不同

>>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
>>> t.branches[0].label = 99          # 改标签：重新绑定一个实例属性
>>> t
Tree(3, [Tree(99, [Tree(5)]), Tree(4)])
>>> t.branches[1].branches.append(Tree(7))   # 加分支：改一个列表
>>> t
Tree(3, [Tree(99, [Tree(5)]), Tree(4, [Tree(7)])])

最后两行的区别是第 8 讲那句老话的翻版：「改名字」和「改对象」是两件事。只有改对象，别的名字才会跟着看到。

别名：一棵子树可以被多处指着

树是嵌套的对象，所以别名（aliasing）在这里格外容易出现：

>>> leaf = Tree(1)
>>> t = Tree(0, [leaf, leaf])          # 同一个叶子塞了两次
>>> t
Tree(0, [Tree(1), Tree(1)])
>>> t.branches[0] is t.branches[1]
True
>>> t.branches[0].label = 99
>>> t
Tree(0, [Tree(99), Tree(99)])

Global frame
    leaf ──→ @1
    t    ──→ @0

@0  Tree instance
    label    ──→ 0
    branches ──→ [ ● , ● ]      ← 列表里两个格子装的是同一个引用
                   │   │
                   └───┴──→ @1  Tree instance
                                label    ──→ 99   (原本是 1)
                                branches ──→ []

repr(t) 打出来是 Tree(1), Tree(1)，看上去像两棵树，其实是同一个对象被打印了两次。打印出来的形状不能告诉你有没有共享。唯一能问出真相的是 is。

这个例子看起来是自找麻烦，但它有真实的来源：任何时候你写 Tree(x, [sub, sub])、或者把同一棵子树 append 到两个父节点下，就制造了共享。list(branches) 只做浅拷贝，救不了你——它复制的是那个装引用的列表，不是被指着的树。

就地修改 vs. 造新树

「把整棵树的每个标签翻倍」有两种写法，学会分辨它们是本讲的核心技能之一。

# 写法 A：就地修改（destructive / mutative）
def double(t):
    t.label = t.label * 2
    for b in t.branches:
        double(b)

# 写法 B：造一棵新树（non-destructive / functional）
def doubled(t):
    return Tree(t.label * 2, [doubled(b) for b in t.branches])

>>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
>>> double(t)                 # 返回 None
>>> t
Tree(6, [Tree(4, [Tree(10)]), Tree(8)])

>>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
>>> doubled(t)
Tree(6, [Tree(4, [Tree(10)]), Tree(8)])
>>> t                         # 原树纹丝不动
Tree(3, [Tree(2, [Tree(5)]), Tree(4)])

「有别名时 A 危险」那条要展开一下：如果 t = Tree(0, [leaf, leaf])，double(t) 会对同一个 @1 执行两次 t.label = t.label * 2，把 1 变成 4 而不是 2。就地修改的正确性依赖于「每个节点只被访问一次」这个前提，而这个前提在有共享的结构上不成立。写法 B 没有这个问题。

>>> print(double(t))
None
>>> double(t).label
Traceback (most recent call last):
  ...
AttributeError: 'NoneType' object has no attribute 'label'

for b in t.branches:
    if b.label < 0:
        t.branches.remove(b)     # 遍历的同时改列表长度

9. 练习一：height

随堂代码 15.py 的第一道题：

def height(t: Tree) -> int:
    """
    Returns the height of a Tree `t`
    (recall that the height of a tree is the depth of the lowest leaf)

    >>> t = Tree(1)
    >>> height(t)
    0
    >>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
    >>> height(t)
    2
    >>> t = Tree(1, [Tree(2, [Tree(3, [Tree(4), Tree(5)])]), Tree(6)])
    >>> height(t)
    3
    """
    if _____________________:
        return 0
    return _____________________

题目到底要什么

先把 doctest 的三棵树画出来——题目提示里就写着「Draw out the trees from the doctests」，这不是客套话。

第一棵           第二棵              第三棵
  1               3                   1
                 / \                 / \
              2      4              2   6
              |                     |
              5                     3
                                   / \
                                  4   5

height = 0      height = 2         height = 3

高度（height）= 最深的那片叶子的深度，而深度（depth）是从根走到该节点要经过的边数。所以：

• 第一棵只有根，根的深度是 0，高度 0。单个节点的高度是 0，不是 1——这是最容易错的边界。
• 第二棵：叶子 5 的深度是 2（3→2→5 走了两条边），叶子 4 的深度是 1。取最大 → 2。
• 第三棵：叶子 4 和 5 的深度都是 3，叶子 6 的深度是 1。取最大 → 3。

怎么想到的

关键一步是把「整棵树的高度」翻译成「子树的高度」之间的关系。想象站在根上，问自己：如果有人免费告诉我每棵子树的高度，我能算出整棵树的高度吗？

能。第二棵树里，子树 2→5 的高度是 1，子树 4 的高度是 0。从根往下走一步就进入某棵子树，所以「根到某片叶子的距离」= 1 + 「那棵子树的根到那片叶子的距离」。要取所有叶子里最深的，就是：

验算：1 + max(1, 0) = 2。对上了。

base case 呢？公式里的 max 在没有分支时无从谈起，所以叶子必须单独处理，而叶子的高度按定义是 0。骨架填出来就是：

def height(t: Tree) -> int:
    if t.is_leaf():
        return 0
    return 1 + max([height(b) for b in t.branches])

代码逐行讲

height(@1)          @1 有分支 [@2, @6]，不是叶子
  height(@2)        @2 有分支 [@3]，不是叶子
    height(@3)      @3 有分支 [@4, @5]，不是叶子
      height(@4)    @4 是叶子 ────────────→ 0
      height(@5)    @5 是叶子 ────────────→ 0
  height(@6)        @6 是叶子 ────────────→ 0

height(@3) = 1 + max([0, 0]) = 1 + 0 = 1
height(@2) = 1 + max([1])    = 1 + 1 = 2
height(@6) = 0                              (叶子，早就算好了)
height(@1) = 1 + max([2, 0]) = 1 + 2 = 3    ← 最终答案

def height(t):
    return 1 + max([height(b) for b in t.branches])

>>> height(Tree(1))
Traceback (most recent call last):
  ...
ValueError: max() arg is an empty sequence

TypeError: '>' not supported between instances of 'Tree' and 'Tree'

10. 练习二：TreeIterator 与层序遍历

第二道题把前半讲的迭代器和后半讲的树接到了一起：写一个迭代器，按层序遍历（level-order traversal，又叫广度优先搜索 breadth-first search / BFS）吐出树上所有标签。

题目给的骨架和 doctest：

class TreeIterator:
    """
    An iterator that returns the elements of a Tree `t`
    when performing a level-order traversal (aka breadth-first search).

    >>> t = Tree(1)
    >>> t_iter = iter(t)
    >>> next(t_iter)
    1
    >>> next(t_iter)
    Traceback (most recent call last):
      ...
    StopIteration

    >>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
    >>> t_iter = iter(t)
    >>> list(t_iter)
    [3, 2, 4, 5]

    >>> t = Tree(1, [Tree(2, [Tree(3, [Tree(4), Tree(5)])]), Tree(6)])
    >>> t_iter = iter(t)
    >>> list(t_iter)
    [1, 2, 6, 3, 4, 5]
    """
    def __init__(self, t: Tree):
        self.queue = [t]

    def __iter__(self):
        return self

    def __next__(self):
        if _____________________:
            curr_node = self.queue._____________________
            for b in curr_node.branches:
                self.queue._____________________
            return _____________________
        else:
            _____________________

为了让 iter(t)（而不是 TreeIterator(t)）就能用，Tree 类里额外加了一个方法：

    # NOTE: This method is new and custom for practice problem 2
    # It is not normally part of the Tree class
    def __iter__(self):
        return TreeIterator(self)

这行注释很实在：标准的 Tree 类没有 __iter__，这是为这道题临时加的。注意它 return TreeIterator(self) 而不是 return self——每次 iter(t) 都新建一个独立的迭代器，各带各的队列。所以一棵树可以被反复遍历，不像第 2 节的 Evens 那样一次性。

怎么想到的：为什么必须用队列，不能用递归

树上大部分算法用递归写最顺，但层序遍历不行。原因是递归的执行顺序天生是深度优先：一进入某个分支，就会一路走到底才回来。而层序要求「把第 1 层全吐完再碰第 2 层」，这跟递归的调用栈是反着的。

那怎么办？观察层序的动作模式：

「从头部取、往尾部加」，这正是队列（queue）——先进先出（FIFO）。它保证了第 2 层的节点全部排在第 1 层节点之后，第 3 层又全部排在第 2 层之后。骨架里给的 self.queue = [t] 就是这个名单，初始只有根。

代码逐行讲

    def __next__(self):
        if self.queue:
            curr_node = self.queue.pop(0)
            for b in curr_node.branches:
                self.queue.append(b)
            return curr_node.label
        else:
            raise StopIteration

关键在于「状态存在哪里」。Evens 的进度是一个整数 self.curr；这里的进度是整个队列。每次 __next__ 只做一小步——取一个、加几个、返回一个——然后把剩下的活儿留在 self.queue 里，等下次调用接着干。迭代器的本质就是「把一个循环拆成一步一步，中间状态存成实例属性」。

      1
     / \
    2   6
    |
    3
   / \
  4   5

验证第二棵 doctest 树

Tree(3, [Tree(2, [Tree(5)]), Tree(4)])：队列 [3] → 吐 3，队列 [2, 4] → 吐 2，队列 [4, 5] → 吐 4，队列 [5] → 吐 5，队列空 → StopIteration。结果 [3, 2, 4, 5]。注意 5 排在 4 后面：5 在第 2 层，4 在第 1 层，层序不看它们在图上的左右位置，只看深度。

Expected:
    [3, 2, 4, 5]
Got:
    [Tree(3, [Tree(2, [Tree(5)]), Tree(4)]), Tree(2, [Tree(5)]), Tree(4), Tree(5)]

>>> t = Tree(1, [Tree(2, [Tree(3, [Tree(4), Tree(5)])]), Tree(6)])
>>> list(t), list(t)
([1, 2, 6, 3, 4, 5], [1, 2, 6, 3, 4, 5])

11. 练习三：Bracket Breaker II（reveal_winner）

最后一道是本学期期中考试第 6 题 Bracket Breaker 的 Tree 类版本——同一道题，从 tree ADT 换成类，doctest 与考卷上的图 1–4 完全一致。它把本讲三样东西全用上了：树递归、造新树（而不是就地改）、以及生成器。

树表示一张淘汰赛对阵表：每个节点标 "W"（这一轮赢了）或 "L"（输了）。reveal_winner 是一个生成器，每次产出「把当前最底层的失败者子树全部剪掉之后」的树，一轮一轮剪，直到没得剪为止——最后剩下的就是一条通往冠军的全胜路径。

题目到底要什么：先把三次输出画出来

初始的树（用 print 的缩进形式看，缩进两格 = 深一层）：

W
  W
    W
      W
      L
    L
      W
      L
  L
    L
      W
      L
    W
      L
      W

三次 next(gen) 依次给出：

W
  W
    W
      W
    L
      W
  L
    L
      W
    W
      W

W
  W
    W
      W
  L
    W
      W

W
  W
    W
      W

第 4 次 next(gen) 抛 StopIteration。

对比初始树和第 1 次输出，被删掉的正是那 4 片 L 叶子。对比第 1 次和第 2 次，被删掉的是两棵 L 子树（各带一个 W 孩子）。规律出来了：

怎么想到的：一次递归要同时回答两个问题

难点在于「有没有后代被剪」这个信息必须从下往上传。判断一个 L 节点该不该被剪，光看它自己不够，得先知道它的子树里发生了什么。

这就是「递归返回一个二元组」这个套路的用武之地。骨架里的辅助函数写得很清楚：

    def prune_lowest_losers(t: Tree):
        """
        Return (new_tree, changed), where:

        (1) new_tree is the pruned version of t,
            or None if t is removed
        (2) changed is True if t itself or a lowest losing subtree was pruned,
            and False otherwise
        """

• new_tree：剪过之后的这棵子树。如果这棵子树整个被删了，就是 None。
• changed：这一轮里，「我自己或者我的某个后代」有没有被剪掉。

changed 的作用有两个：往上传给父节点当作「你别剪自己了，下面还有活儿」的信号；以及在最外层告诉驱动循环「这一轮到底剪没剪，要不要继续」。

代码逐行讲

        # BASE CASE
        if t.is_leaf():
            if t.label == "L":
                return None, True
            return Tree(t.label), False

叶子没有后代，所以「是不是最底层的 L」就等于「标签是不是 L」——是就删掉自己（None）并汇报 True；不是就原样保留并汇报 False。

注意保留时写的是 Tree(t.label) 而不是 t：造一片新叶子。这道题从头到尾都在造新树，原树一个字节都没改（所以 reveal_winner 跑完之后 t 还是完整的初始树）。写 return t, False 其实也能通过全部 doctest，但那样产出的树会和原树共享节点——一旦有人改了其中一棵，另一棵跟着变。第 8 节讲的别名问题在这里就是活的。

        # RECURSIVE CASE (i)
        new_branches = []
        changed = False

        for b in t.branches:
            new_b, child_changed = prune_lowest_losers(b)
            if new_b is not None:
                new_branches.append(new_b)
            changed = changed or child_changed

为什么必须用 is not None 而不是 if new_b:？因为 Tree 实例没有定义 __bool__ 或 __len__，所有实例都是 truthy，所以这里 if new_b: 碰巧也能工作。但只要哪天给 Tree 加上 __len__，空树就会变成 falsy，代码静默出错。判断「是不是 None」就该用 is not None，这是纪律。

        # RECURSIVE CASE (ii)
        if t.label == "L" and not changed:
            return None, True

这是全题最关键的两行。走到这里说明：所有分支都递归处理完了，而 changed 记录着「下面有没有动过」。

• t.label == "L"：我是个失败者。
• not changed：我的整个子树里一个 L 都没有（否则至少会有一次剪枝，changed 就会是 True）。

两条同时成立，我就是「最底层的失败者」——把自己整个删掉，返回 None, True。注意此时 new_branches 被直接丢弃了，因为整棵子树都不要了，白算的那些孩子也一并作废。

        # RECURSIVE CASE (iii)
        return Tree(t.label, new_branches), changed

其余所有情况：我保留下来，带着剪过的新分支。changed 原样往上传——如果下面剪过，父节点就知道自己这一轮不该动。

驱动循环：生成器怎么一轮一轮吐

    current = t
    changed = True
    while changed:
        current, changed = prune_lowest_losers(current)
        if changed:
            yield current

>>> gen = reveal_winner(t)
>>> type(gen)
<class 'generator'>

R = W
├─ A = W
│  ├─ A1 = W ── [A1a = W(叶), A1b = L(叶)]
│  └─ A2 = L ── [A2a = W(叶), A2b = L(叶)]
└─ B = L
   ├─ B1 = L ── [B1a = W(叶), B1b = L(叶)]
   └─ B2 = W ── [B2a = L(叶), B2b = W(叶)]

A1a = W(叶) → (Tree('W'), False)      A1b = L(叶) → (None, True)
A2a = W(叶) → (Tree('W'), False)      A2b = L(叶) → (None, True)
B1a = W(叶) → (Tree('W'), False)      B1b = L(叶) → (None, True)
B2a = L(叶) → (None, True)            B2b = W(叶) → (Tree('W'), False)

A1(标签 W)：new_branches=[W]，changed = False or True = True
           标签不是 L → 走 (iii) → (Tree('W', [Tree('W')]), True)

A2(标签 L)：new_branches=[W]，changed = True
           (ii) 的条件 t.label=="L" 成立，但 not changed 为 False → 不剪！
           → 走 (iii) → (Tree('L', [Tree('W')]), True)

B1(标签 L)：new_branches=[W]，changed = True → 同上不剪
           → (Tree('L', [Tree('W')]), True)

B2(标签 W)：new_branches=[W]（B2a 返回 None 被跳过），changed = True
           → (Tree('W', [Tree('W')]), True)

A(标签 W)：两个孩子都非 None，都汇报 True → changed=True
          → (Tree('W', [W[W], L[W]]), True)

B(标签 L)：两个孩子都非 None，changed=True
          (ii)：是 L，但 changed 为 True → 不剪
          → (Tree('L', [L[W], W[W]]), True)

R' = W
├─ A' = W ── [A1' = W[W],  A2' = L[W]]
└─ B' = L ── [B1' = L[W],  B2' = W[W]]

W
  W
    W
      W
  L
    W
      W

本讲小结

动手练习

练习 1：别名的后果

下面这段代码执行完，print(t) 会打印什么？

sub = Tree(2, [Tree(5)])
t = Tree(1, [sub, sub])
t.branches[0].label = 99
t.branches[1].branches.append(Tree(7))

1
  99
    5
    7
  99
    5
    7

练习 2：换个容器就换一种遍历

把 TreeIterator.__next__ 里的 self.queue.pop(0) 改成 self.queue.pop()，其余不动。对这棵树：

t = Tree(1, [Tree(2, [Tree(3, [Tree(4), Tree(5)])]), Tree(6)])

list(iter(t)) 会得到什么？

练习 3：两种「加一层」

写两个函数，都把树上每个叶子换成「带一个同标签孩子」的节点（例如叶子 Tree(5) 变成 Tree(5, [Tree(5)])）。一个就地修改，一个造新树。

# 就地修改：注意不返回任何东西
def grow(t):
    if t.is_leaf():
        t.branches.append(Tree(t.label))
    else:
        for b in t.branches:
            grow(b)

# 造新树
def grown(t):
    if t.is_leaf():
        return Tree(t.label, [Tree(t.label)])
    return Tree(t.label, [grown(b) for b in t.branches])

def grow_bad(t):
    if t.is_leaf():
        t.branches.append(Tree(t.label))
    for b in t.branches:          # 少了 else
        grow_bad(b)

RecursionError: maximum recursion depth exceeded

练习 4：changed 汇报错了会怎样

把 prune_lowest_losers 的 base case 改成：

        if t.is_leaf():
            if t.label == "L":
                return None, False      # 原本是 True
            return Tree(t.label), False

对课上那棵初始树，第一次 next(gen) 打印出来的树会有什么不同？

W
  W
    W
      W
  L
    W
      W

练习 5：这个 height 错在哪

def height(t):
    if t.is_leaf:
        return 0
    return 1 + max([height(b) for b in t.branches])

它对三个 doctest 分别返回什么？为什么不报错？

>>> t = Tree(3, [Tree(2, [Tree(5)]), Tree(4)])
>>> t.is_leaf
<bound method Tree.is_leaf of Tree(3, [Tree(2, [Tree(5)]), Tree(4)])>
>>> bool(t.is_leaf)
True
>>> t.is_leaf()
False