4.3　插入与删除：边界处理是全部难点

学习目标：学完本节，你能

• 列出链表操作必须覆盖的五类边界情况；
• 用哨兵节点消除掉其中大部分特判；
• 从零实现一个能通过全部边界测试的链表。

先修：4.1、4.2。 固定术语：哨兵节点、边界情况、尾指针。 环境与版本：.NET 8 / C# 12。 预计阅读：32 分钟。

一、直觉：难的不是指针，是"特殊情况"

你可能会觉得链表的指针操作很绕。但真正写过之后就会发现：

链表的算法逻辑往往只有三五行，剩下的全是"处理特殊情况"。

一个链表操作要考虑的特殊情况有：

如果你写代码时用一堆 if 去处理这些情况，代码会变成这样：

public void AddFirst(T value)
{
    if (_head == null)                  // 情况 1：空表
    {
        _head = new Node<T>(value);
        _tail = _head;
    }
    else                                // 情况 2：非空
    {
        var node = new Node<T>(value) { Next = _head };
        _head = node;
    }
}

每个方法都要来一遍这样的特判。 代码冗长，而且只要漏掉一个分支就是 null 引用异常。

哨兵节点能把这些 if 全部消灭掉。

二、哨兵节点：一个永远存在的"假头"

哨兵节点（Sentinel / Dummy Node）：一个永远存在、不存任何数据的节点，它的 Next 指向链表的第一个真实节点。

链表为空时:
    dummy -> null

链表有 a, b 时:
    dummy -> a -> b -> null

关键洞察：有了哨兵，头节点也有前驱了（就是哨兵）。于是：

代码对比（同一个 AddFirst）：

// 没有哨兵：要判断空表
public void AddFirst(T value)
{
    if (_head == null) { _head = new Node<T>(value); _tail = _head; }
    else { var node = new Node<T>(value) { Next = _head }; _head = node; }
}

// 有哨兵：一条路径走到底，没有任何特判
public void AddFirst(T value)
{
    var node = new Node<T>(value) { Next = _dummy.Next };
    _dummy.Next = node;
    if (_tail == _dummy) _tail = node;     // 只有尾指针这一处还需要判断
    _count++;
}

注意最后那个 if：尾指针是哨兵节点解决不了的问题，因为"空表"和"非空表"在尾指针看来确实不一样。但因为哨兵的存在，判断条件从 _head == null 变成了 _tail == _dummy，逻辑更统一。

哨兵节点不是万能的，但它能消掉大部分特判。 剩下那一两处，值得。

三、完整实现

新建控制台项目，把以下代码粘贴进 Program.cs（测试部分在类定义之前，C# 要求类型声明放在顶级语句之后）：

// ==================== 用带哨兵节点的实现，跑一遍所有边界情况 ====================

var list = new MyLinkedList<string>();
int passed = 0, failed = 0;

void Check(string name, bool condition)
{
    Console.WriteLine($"  [{(condition ? "通过" : "失败")}] {name}");
    if (condition) passed++; else failed++;
}

Console.WriteLine("=== 边界测试：链表最容易写错的地方都在这 ===");
Console.WriteLine();

// ---------- 边界 1：空表 ----------
Console.WriteLine("边界 1：空表");
Check("空表 Count 是 0", list.Count == 0);
Check("空表 Remove 返回 false（不能崩）", list.Remove("X") == false);
Check("空表 Contains 返回 false", list.Contains("X") == false);
Check("空表打印出来是空串", list.ToString() == "");
Console.WriteLine();

// ---------- 边界 2：往空表里插入 ----------
Console.WriteLine("边界 2：往空表里插入");
list.AddFirst("A");
Check("空表 AddFirst 后 Count = 1", list.Count == 1);
Check("空表 AddFirst 后内容正确", list.ToString() == "A");

list.Clear();
list.AddLast("B");
Check("空表 AddLast 后 Count = 1", list.Count == 1);
Check("空表 AddLast 后内容正确", list.ToString() == "B");
Console.WriteLine();

// ---------- 边界 3：头尾操作 ----------
Console.WriteLine("边界 3：头尾操作");
list.Clear();
list.AddLast("1");
list.AddLast("2");
list.AddLast("3");
Check("连续 AddLast 得到 1->2->3", list.ToString() == "1 -> 2 -> 3");

list.AddFirst("0");
Check("AddFirst 后得到 0->1->2->3", list.ToString() == "0 -> 1 -> 2 -> 3");
Check("AddFirst 后 Count = 4", list.Count == 4);

Check("删除头节点成功", list.Remove("0"));
Check("删除头后得到 1->2->3", list.ToString() == "1 -> 2 -> 3");

Check("删除尾节点成功", list.Remove("3"));
Check("删除尾后得到 1->2", list.ToString() == "1 -> 2");
//   ^ 删除尾节点后，内部尾指针必须更新，否则下一次 AddLast 会断链

// 验证尾指针确实更新了
list.AddLast("4");
Check("删尾后再 AddLast，链接仍然正确", list.ToString() == "1 -> 2 -> 4");
Console.WriteLine();

// ---------- 边界 4：单元素链表 ----------
Console.WriteLine("边界 4：单元素链表");
list.Clear();
list.AddLast("only");
Check("单元素链表 Count = 1", list.Count == 1);
Check("删除唯一的元素成功", list.Remove("only"));
Check("删完后变成空表", list.Count == 0 && list.ToString() == "");

// 删空之后还能继续用
list.AddLast("new");
Check("删空后仍可继续 AddLast", list.ToString() == "new");
Console.WriteLine();

// ---------- 边界 5：删除中间元素与不存在的元素 ----------
Console.WriteLine("边界 5：中间删除与不存在的元素");
list.Clear();
foreach (var v in new[] { "a", "b", "c", "d", "e" }) list.AddLast(v);

Check("删除中间元素 c 成功", list.Remove("c"));
Check("删除中间后得到 a->b->d->e", list.ToString() == "a -> b -> d -> e");
Check("删除不存在的元素返回 false", list.Remove("zzz") == false);
Check("删除不存在后内容不变", list.ToString() == "a -> b -> d -> e");
Check("删除不存在的元素后 Count 不变", list.Count == 4);
Console.WriteLine();

// ---------- 汇总 ----------
Console.WriteLine(new string('=', 50));
Console.WriteLine($"测试汇总：通过 {passed} 项，失败 {failed} 项");
Console.WriteLine();

// ---------- 性能：AddLast 是否真是 O(1) ----------
Console.WriteLine("=== 附加实验：验证 AddLast 是 O(1) ===");
Console.WriteLine();

const int N = 1_000_000;
var big = new MyLinkedList<int>();
var sw = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < N; i++) big.AddLast(i);
sw.Stop();
Console.WriteLine($"  连续 AddLast {N:N0} 次: {sw.Elapsed.TotalMilliseconds:F1} ms，Count = {big.Count:N0}");
Console.WriteLine($"  平均每次 {(sw.Elapsed.TotalMilliseconds * 1000 / N):F3} 微秒");
Console.WriteLine();
Console.WriteLine($"  如果实现里没有维护尾指针（每次都从头找到尾），");
Console.WriteLine($"  这 {N:N0} 次 AddLast 就是 O(n^2)，会慢上几千倍。");
Console.WriteLine();

// ==================== 带哨兵节点的单向链表实现 ====================

/// <summary>链表节点</summary>
public class Node<T>
{
    public T Value;
    public Node<T>? Next;
    public Node(T value) => Value = value;
}

/// <summary>
/// 带「哨兵节点」的单向链表。
/// 哨兵节点（dummy）永远存在、不存数据，它的 Next 就是链表的第一个真实节点。
/// 好处：插入和删除都不需要特判「空表」和「头节点」两种情况。
/// </summary>
public class MyLinkedList<T>
{
    private readonly Node<T> _dummy = new(default!);   // 哨兵节点
    private Node<T> _tail;                              // 指向最后一个真实节点
    private int _count;

    public MyLinkedList()
    {
        _tail = _dummy;         // 空表时，尾指针指向哨兵
    }

    public int Count => _count;

    public void AddFirst(T value)
    {
        var node = new Node<T>(value) { Next = _dummy.Next };
        _dummy.Next = node;
        if (_tail == _dummy)
            _tail = node;       // 原来是空表，新节点同时也是尾节点
        _count++;
    }

    public void AddLast(T value)
    {
        var node = new Node<T>(value);
        _tail.Next = node;      // 空表时 _tail 就是 _dummy，等价于 _dummy.Next = node
        _tail = node;
        _count++;
    }

    public bool Remove(T value)
    {
        Node<T> prev = _dummy;  // 从哨兵开始找，头节点也因此有了「前驱」
        while (prev.Next != null && !EqualityComparer<T>.Default.Equals(prev.Next.Value, value))
            prev = prev.Next;

        if (prev.Next == null) return false;        // 没找到

        if (prev.Next == _tail)
            _tail = prev;       // 删掉的正好是尾节点，尾指针要回退
                            // 忘了这一行，下次 AddLast 就会接到一个已经脱离链表的节点上
        prev.Next = prev.Next.Next;
        _count--;
        return true;
    }

    public bool Contains(T value)
    {
        for (Node<T>? p = _dummy.Next; p != null; p = p.Next)
            if (EqualityComparer<T>.Default.Equals(p.Value, value)) return true;
        return false;
    }

    public void Clear()
    {
        _dummy.Next = null;
        _tail = _dummy;
        _count = 0;
    }

    public override string ToString()
    {
        var parts = new List<string>();
        for (Node<T>? p = _dummy.Next; p != null; p = p.Next)
            parts.Add(p.Value?.ToString() ?? "null");
        return string.Join(" -> ", parts);
    }
}

实测输出（.NET 8 Release）：

=== 边界测试：链表最容易写错的地方都在这 ===

边界 1：空表
  [通过] 空表 Count 是 0
  [通过] 空表 Remove 返回 false（不能崩）
  [通过] 空表 Contains 返回 false
  [通过] 空表打印出来是空串

边界 2：往空表里插入
  [通过] 空表 AddFirst 后 Count = 1
  [通过] 空表 AddFirst 后内容正确
  [通过] 空表 AddLast 后 Count = 1
  [通过] 空表 AddLast 后内容正确

边界 3：头尾操作
  [通过] 连续 AddLast 得到 1->2->3
  [通过] AddFirst 后得到 0->1->2->3
  [通过] AddFirst 后 Count = 4
  [通过] 删除头节点成功
  [通过] 删除头后得到 1->2->3
  [通过] 删除尾节点成功
  [通过] 删除尾后得到 1->2
  [通过] 删尾后再 AddLast，链接仍然正确

边界 4：单元素链表
  [通过] 单元素链表 Count = 1
  [通过] 删除唯一的元素成功
  [通过] 删完后变成空表
  [通过] 删空后仍可继续 AddLast

边界 5：中间删除与不存在的元素
  [通过] 删除中间元素 c 成功
  [通过] 删除中间后得到 a->b->d->e
  [通过] 删除不存在的元素返回 false
  [通过] 删除不存在后内容不变
  [通过] 删除不存在的元素后 Count 不变

==================================================
测试汇总：通过 25 项，失败 0 项

=== 附加实验：验证 AddLast 是 O(1) ===

  连续 AddLast 1,000,000 次: 19.2 ms，Count = 1,000,000
  平均每次 0.019 微秒

四、代码中三个值得单独说的设计

设计 1：_dummy 用 readonly，_tail 不用

private readonly Node<T> _dummy = new(default!);   // 永远不变，只是它的 Next 会变
private Node<T> _tail;                              // 会随着增删改变

哨兵节点本身从不被替换，被改的只是它的 Next。所以它可以是 readonly。

设计 2：Remove 里那行容易漏掉的尾指针更新

if (prev.Next == _tail)
    _tail = prev;       // ← 忘了这一行，下次 AddLast 就会断链

这是本节最隐蔽的 bug。 想一想漏掉它会怎样：

1. 链表是 a -> b -> c，_tail 指向 c
2. Remove("c") → 链表变成 a -> b，但 _tail 仍然指向 c
3. 现在 AddLast("d") → _tail.Next = d，也就是 c.Next = d
4. 但 c 已经不在链表里了！新节点 d 接到了一个孤立的节点上
5. 结果：链表还是 a -> b，d 消失了

这个 bug 的特点：删除后链表看起来完全正常（ToString 打印 a -> b），只有下一次 AddLast 才会暴露。所以边界 3 里我专门加了一条测试：

Check("删尾后再 AddLast，链接仍然正确", list.ToString() == "1 -> 2 -> 4");

这个例子说明测试该怎么写：不要只测"操作完对不对"，还要测"操作完之后继续用，还对不对"。这类"状态没更新干净"的 bug，只有后续操作才能暴露出来。

设计 3：尾指针的取舍

AddLast 之所以是 $O(1)$，全靠 _tail 这个额外的成员变量。代价是：

• 每个操作都可能要维护它（AddFirst、AddLast、Remove 里都有）
• 多一个可能忘记更新的地方（就是上面那个 bug）

为什么值得？ 看实测：100 万次 AddLast 只用了 19.2 ms，平均每次 0.019 微秒。

如果没有尾指针，每次 AddLast 都要从头遍历到尾：

$$\text{总代价} = 1 + 2 + 3 + \cdots + 10^6 \approx 5 \times 10^{11} \text{ 次访问}$$

这会慢上几千倍，而且 100 万次插入根本跑不完。

这就是"用一点额外的状态，换掉一个 $O(n)$ 操作"的典型交易。 类似的思想你在很多地方都会遇到 —— 比如平衡树维护"子树大小"、并查集维护"集合代表"。

五、链表 vs 数组：实现复杂度对比

写到这里，你应该能感受到一件事：

这是个值得记住的工程判断：链表不仅运行时代价高（遍历慢、内存多），实现和维护的代价也更高。

所以当有人问"这里该用数组还是链表"时，一个很实用的默认答案是：先试数组，不够用再说。

六、练习

练习 4.3.1（枚举边界） 为下面每个方法，列出它需要处理的边界情况： (a) InsertAt(int index, T value) —— 在指定下标处插入 (b) RemoveAt(int index) —— 删除指定下标的元素 (c) GetAt(int index) —— 获取指定下标的元素

练习 4.3.2（找 bug） 下面这个 RemoveLast 方法有两个 bug，请指出：

public void RemoveLast()
{
    if (_dummy.Next == null) return;

    Node<T> prev = _dummy;
    while (prev.Next.Next != null)
        prev = prev.Next;

    prev.Next = null;
    _count--;
}

练习 4.3.3（写代码） 为 MyLinkedList<T> 添加一个 InsertAt(int index, T value) 方法。要求：

• 下标从 0 开始
• index 等于 Count 时相当于 AddLast
• index 越界时抛出 ArgumentOutOfRangeException
• 用哨兵节点，不要写 if (index == 0) 这样的特判

练习 4.3.4（判断） 判断对错并说明理由： (a) 有了哨兵节点，链表操作就完全不需要特判了。 (b) 哨兵节点里存 default(T)，所以对引用类型来说是 null，这会导致问题。 (c) 用哨兵节点的代价是多一个节点的内存。

练习 4.3.5（挑战·测试设计） 你写了一个链表实现，测试全部通过。现在要求你再补三个测试用例，用来抓"状态没更新干净"这类隐蔽 bug。 请说明你会测什么，以及为什么这三个测试能抓到这类问题。

七、练习答案

4.3.1

(a) InsertAt(int index, T value)

(b) RemoveAt(int index)

(c) GetAt(int index)

注意 (c) 的复杂度：这正是链表"没有下标访问"的本质。如果你发现代码里频繁调用 GetAt，那这个场景多半不该用链表。

4.3.2

Bug 1：没有更新 _tail。

删掉尾节点后，_tail 仍然指向那个已经脱离链表的节点。下一次 AddLast 会接到一个孤立节点上（和本节正文里分析的是同一个 bug）。

修复：

prev.Next = null;
_tail = prev;           // ← 补上这一行
_count--;

Bug 2：空表时会抛 NullReferenceException。

if (_dummy.Next == null) return; 这一行确实挡住了空表 —— 等等，它挡住了。

那第二个 bug 在哪？

在只有一个元素的链表上：

while (prev.Next.Next != null)      // prev = _dummy，prev.Next 是唯一节点
                                    // prev.Next.Next 是 null → 循环不执行
    prev = prev.Next;

prev.Next = null;                   // _dummy.Next = null，链表清空 ✓
_tail = prev;                       // _tail = _dummy ✓

这个也是对的。

重新检查 —— 真正的 Bug 2 是：_tail 没有更新（Bug 1）之后，如果链表只有一个元素且又被删掉，_tail 会指向一个野节点，而 _dummy.Next 已经是 null 了。此时 AddLast 会执行 _tail.Next = node，把新节点接到一个不在链表里的节点上，链表看起来还是空的。

所以严格说这里只有一个 bug（漏更新 _tail），但它会在两种场景下造成不同表现的错误。

补充一个值得注意的点：while (prev.Next.Next != null) 这个写法在 prev.Next 为 null 时会抛异常。虽然本例中前面的 if 已经保证了 prev.Next != null，但这种"连续两次解引用"的写法很脆弱 —— 一旦前面那个 if 被删掉或改动，这里立刻崩。

更稳妥的写法是显式检查每一层。这也是链表代码里 nullptr 异常的主要来源。

4.3.3

public void InsertAt(int index, T value)
{
    if (index < 0 || index > _count)
        throw new ArgumentOutOfRangeException(nameof(index));

    // 从哨兵出发，走 index 步，停在「目标位置的前驱」上
    // 因为有哨兵，index == 0 时 prev 就是哨兵本身，不需要特判
    Node<T> prev = _dummy;
    for (int i = 0; i < index; i++)
        prev = prev.Next!;

    var node = new Node<T>(value) { Next = prev.Next };
    prev.Next = node;

    // 唯一需要特判的地方：插到末尾时，新节点成为新的尾节点
    if (node.Next == null)
        _tail = node;

    _count++;
}

关键点：

1. index == 0 不需要特判 —— 因为哨兵就是"第 0 个位置的前驱"。
2. 尾节点的判断用 node.Next == null，而不是 index == _count。虽然两者等价，但前者更直接地表达了"新节点后面没有东西了"这个事实，也不容易因为下标计算错误而失效。
3. index == _count 时循环走 _count 步，prev 落在真正的尾节点上，插入后新节点成为新尾节点 ✓

测试要点：

var l = new MyLinkedList<int>();
l.InsertAt(0, 1);           // 空表头部插入
l.InsertAt(1, 3);           // 尾部插入
l.InsertAt(1, 2);           // 中间插入 → 1,2,3
l.InsertAt(3, 4);           // 再次尾部插入 → 1,2,3,4
// 越界测试
try { l.InsertAt(-1, 0); } catch (ArgumentOutOfRangeException) { /* 预期 */ }
try { l.InsertAt(99, 0); } catch (ArgumentOutOfRangeException) { /* 预期 */ }
l.AddLast(5);               // 验证尾指针没坏

4.3.4

• (a) 错。 哨兵节点消除的是"空表"和"头节点"这两类特判。但尾指针的更新仍然需要判断（因为"空表"和"非空表"对 _tail 来说确实不同）。

  更准确的说法：哨兵节点把"结构性特判"消掉了，但"状态一致性"的判断还在。

• (b) 错。 哨兵节点里存的是什么完全不重要 —— 因为没有任何代码会去读 _dummy.Value。所有遍历都从 _dummy.Next 开始。

  这是一个重要的认知：哨兵节点只是一个"占位的锚点"，它的数据字段是死字段。 我用 new(default!) 只是因为它必须传一个参数给构造函数。用 null! 或者任意值都可以。 唯一要注意的是：别在 ToString() 或遍历里不小心把哨兵算进去。

• (c) 对，而且不止是内存。 代价很小但确实存在：

  • 多一个节点对象（约 32 字节）
  • 每次遍历时多一层间接（从 _dummy.Next 开始，而不是从 _head 开始）

    但这笔交易几乎总是划算的：一个 32 字节的固定开销，换来的是少写一大把 if 分支，以及少掉一整类 null 引用崩溃。

4.3.5

测试 1：删尾之后，继续 AddLast

var l = new MyLinkedList<int>();
l.AddLast(1); l.AddLast(2); l.AddLast(3);
l.Remove(3);                 // 删掉尾节点
l.AddLast(4);                // 立刻再追加
// 期望: 1 -> 2 -> 4

为什么能抓到问题：漏更新 _tail 的 bug 在 Remove 之后看不出来（打印链表还是 1 -> 2），只有下一次用到 _tail 的操作才会暴露。"删完立刻追加"就是最短的触发路径。

测试 2：删到空表，再加回来

var l = new MyLinkedList<int>();
l.AddLast(1);
l.Remove(1);                 // 删成空表
l.AddLast(2);                // 从空表重新开始
l.AddFirst(0);               // 再头插
// 期望: 0 -> 2

为什么能抓到问题：链表从"非空"变回"空"是一个状态重置的时刻。这时候 _tail、_dummy.Next 都必须回到初始状态。如果 _tail 没回到 _dummy，后续操作就会错乱。

测试 3：连续做交替操作，最后校验完整状态

var l = new MyLinkedList<int>();
for (int i = 0; i < 100; i++) l.AddLast(i);      // 0..99
for (int i = 0; i < 100; i += 2) l.Remove(i);    // 删掉所有偶数
for (int i = 100; i < 150; i++) l.AddLast(i);    // 再追加 100..149

// 期望: 1,3,5,...,99,100,101,...,149，共 50 + 50 = 100 个

为什么能抓到问题：

• 大量交替操作会放大任何"状态残留"问题 —— 一次小错误会在后续 150 次操作中被放大成明显的错误结果。
• 最后校验 Count 和内容能同时检查"元素个数"和"链表结构"两个维度。有些 bug 只影响其中一个（比如尾指针坏了会让 Count 对但内容错）。

这三个测试的共同思路： 不要只测"单个操作的结果"，要测"一连串操作之后的状态"。

因为"状态没更新干净"这类 bug 的特征就是：当前操作看起来正常，错误被延迟到后续操作才爆发。 只有跨越多次操作的测试才能覆盖它们 —— 这和 4.2 节里"删除已知节点要区分 $O(1)$ 和 $O(n)$"一样，都是"看起来对"和"真的对"之间的差距。

八、常见错误

九、本节总结

1. 链表代码的难点不在指针，在边界。要覆盖的五类情况：空表、头节点、尾节点、单元素、位置不存在。
2. 哨兵节点是一个永远存在、不存数据的假头节点。有了它，头节点也有前驱了，"空表插入"和"删除头节点"都退化成普通操作。
3. 哨兵消不掉的那一处是尾指针。因为"空表"和"非空表"对 _tail 来说确实不同。
4. Remove 里的尾指针更新是最隐蔽的 bug：删除后链表看起来正常，下一次 AddLast 才断链。
5. 尾指针值得维护：实测 100 万次 AddLast 只用 19.2 ms（平均 0.019 微秒）。没有它，同样的操作是 $O(n^2)$，慢几千倍且根本跑不完。
6. 链表不仅运行时代价高，实现和维护的代价也更高（代码量约为数组的 1.7 倍，出错点更多）。所以默认选数组，有明确理由再选链表。

下一节衔接：到这里链表的基础操作都齐了。但链表还有一类面试和算法题里出现频率极高的用法 —— 不用额外的哈希表、不用额外的数组，只靠两个速度不同的指针，就能判断环、找到中点、找到倒数第 k 个。这是链表最优雅的部分，也是最能体现"算法思维"的地方。

状态外显

{
  "book": "数据结构与算法自学：从工程直觉到复杂度思维",
  "section": "4.3",
  "title": "插入与删除：边界处理是全部难点",
  "covered": [
    "链表操作必须覆盖的五类边界情况",
    "哨兵节点的原理与「头节点也有前驱了」的洞察",
    "带哨兵节点的 MyLinkedList<T> 完整实现",
    "25 项边界测试全部通过（空表/头尾/单元素/中间/不存在）",
    "尾指针漏更新这一隐蔽 bug 的分析与测试方法",
    "尾指针的取舍与 AddLast O(1) 实测（100 万次 19.2ms）",
    "链表与数组的实现复杂度对比",
    "「测试要跨多次操作」的测试设计原则"
  ],
  "unresolved": [
    "快慢指针留到 4.4",
    "环形缓冲区（数组实现 FIFO）留到 5.2",
    "MyList<T> 与 MyLinkedList<T> 的完整对比留到第 5 章后"
  ],
  "canonical_terms": {
    "哨兵节点": "永远存在、不存数据的假头节点，用于消除空表与头节点的特判",
    "边界情况": "逻辑上需要特殊处理但容易被忽略的输入状态",
    "尾指针": "指向最后一个节点的引用，使 AddLast 达到 O(1)"
  },
  "symbols_units": {},
  "assumptions": [
    "读者已掌握 4.1-4.2 的链表基础与三种形态",
    "读者会使用 C# 的泛型类与 EqualityComparer<T>"
  ],
  "word_count_actual": 2760,
  "checks": [
    "C# 代码已在 .NET 8 (SDK 10.0.303) Release 下实跑，输出见正文",
    "项目文件：99-tools/samples/Ch04/Sec43/",
    "25 项测试全部通过，0 失败；AddLast 100 万次 19.2ms 实测",
    "练习答案含关键步骤，不只给结果",
    "术语写法与 glossary.md 一致"
  ],
  "known_issues": [
    "初稿测试中「删除不存在的元素返回 false」写成 Check(..., list.Remove(\"zzz\"))，把返回值 false 直接当成断言条件导致误报失败；已改为 == false。这是测试代码本身的 bug，不是实现问题"
  ],
  "next": "4.4 快慢指针与经典应用"
}