链表节点删除：迭代与递归解法详解及边界处理

1. 问题背景与核心思路

链表操作是算法面试中的高频考点，LeetCode 203题要求删除链表中所有满足特定条件的节点。这道题看似简单，却隐藏着多个需要特别注意的边界条件。我在实际面试中多次遇到候选人在这里翻车，主要原因是对链表指针操作的理解不够透彻。

链表删除操作的核心在于正确处理前驱节点与后继节点的连接关系。与数组不同，链表节点在内存中非连续存储，因此不能像数组那样通过下标直接访问相邻元素。这就意味着我们必须通过指针逐个遍历，并在遍历过程中维护好节点间的引用关系。

2. 基础解法与实现细节

2.1 迭代解法标准实现

最直观的解法是使用双指针进行迭代遍历。我们需要两个指针：current指向当前检查的节点，prev指向前一个节点。当current节点值匹配目标值时，修改prev的next指针跳过当前节点。

python复制def removeElements(head: ListNode, val: int) -> ListNode:
    dummy = ListNode(0)
    dummy.next = head
    prev, current = dummy, head
    
    while current:
        if current.val == val:
            prev.next = current.next
        else:
            prev = current
        current = current.next
    
    return dummy.next

这个实现有几个关键点：

1. 使用dummy节点处理头节点删除的情况
2. prev指针始终指向当前检查节点的前驱
3. 只有不删除时才移动prev指针

2.2 递归解法的精妙之处

递归解法虽然空间复杂度较高(O(n))，但代码极其简洁：

python复制def removeElements(head: ListNode, val: int) -> ListNode:
    if not head:
        return None
    head.next = removeElements(head.next, val)
    return head.next if head.val == val else head

递归的核心思想是：先处理子链表，再决定当前节点的去留。这种"后序遍历"的方式让代码看起来非常优雅，但在处理超长链表时可能导致栈溢出。

3. 边界条件与易错点

3.1 头节点处理陷阱

很多初学者会忽略头节点也需要被删除的情况。直接使用原始头指针会导致第一个节点无法被正确处理。这就是为什么我们需要dummy节点的原因：

注意：没有dummy节点时，删除头节点需要特殊处理，这会增加代码复杂度并容易出错。

3.2 内存释放问题

在C++等需要手动管理内存的语言中，删除节点后应该释放内存：

cpp复制ListNode* toDelete = prev->next;
prev->next = toDelete->next;
delete toDelete;  // 释放内存

但在Python/Java等有垃圾回收的语言中，可以省略这一步。

3.3 连续删除情况

当链表中有连续多个需要删除的节点时，prev指针不应该立即移动：

code复制输入: 1->2->2->3, val=2
处理第二个2时，prev应保持在第一个2的前驱位置

4. 复杂度分析与优化思路

4.1 时间复杂度

两种解法都是O(n)时间复杂度，因为需要完整遍历整个链表一次。递归解法由于函数调用栈的原因，空间复杂度也是O(n)，而迭代解法是O(1)。

4.2 实际性能考量

在真实面试场景中，迭代解法通常是更优选择：

1. 避免递归栈溢出风险
2. 常数项更小
3. 更容易解释和验证正确性

但对于日常刷题，理解递归解法有助于培养递归思维，这在解决更复杂的链表问题（如反转链表、合并链表）时很有帮助。

5. 测试用例设计

完整的测试应该包含以下情况：

1. 空链表
2. 头节点需要删除
3. 尾节点需要删除
4. 连续多个节点需要删除
5. 所有节点都需要删除
6. 普通中间节点删除

示例测试用例：

python复制def test_removeElements():
    # 案例1：删除中间节点
    lst1 = build_list([1,2,6,3,4,5,6])
    assert list_to_array(removeElements(lst1, 6)) == [1,2,3,4,5]
    
    # 案例2：删除所有节点
    lst2 = build_list([7,7,7,7])
    assert list_to_array(removeElements(lst2, 7)) == []
    
    # 案例3：空链表
    assert removeElements(None, 1) is None
    
    # 案例4：删除头节点
    lst3 = build_list([1,2,3])
    assert list_to_array(removeElements(lst3, 1)) == [2,3]

6. 扩展思考与变种问题

掌握了基础解法后，可以尝试以下变种问题：

1. 删除重复元素（保留单个副本）
2. 删除倒数第n个节点
3. 删除所有重复元素（不保留任何副本）
4. 按照给定节点引用直接删除节点（无头指针访问）

以"删除倒数第n个节点"为例，其核心技巧是使用快慢指针：

python复制def removeNthFromEnd(head: ListNode, n: int) -> ListNode:
    dummy = ListNode(0)
    dummy.next = head
    fast = slow = dummy
    
    for _ in range(n+1):
        fast = fast.next
        
    while fast:
        fast = fast.next
        slow = slow.next
    
    slow.next = slow.next.next
    return dummy.next

7. 工程实践中的链表操作

在实际工程中，链表操作有一些最佳实践：

1. 尽量使用哨兵节点简化边界处理
2. 在修改链表结构前，先画出示意图
3. 对长链表考虑迭代而非递归
4. 在多线程环境下需要加锁保护

比如Linux内核中的链表实现就大量使用了哨兵节点和嵌入式的链表结构，这种设计值得学习：

c复制struct list_head {
    struct list_head *next, *prev;
};

8. 常见面试问题与回答思路

面试官可能会围绕这个问题深入提问：
Q: 如何处理超大链表？
A: 优先选择迭代解法避免栈溢出，考虑分块处理

Q: 如何验证链表操作的正确性？
A: 编写全面的测试用例，包括边界条件；使用可视化工具逐步验证

Q: 如果链表有环怎么办？
A: 先检测环的存在（快慢指针），本题中带环链表无意义

我在实际面试中遇到过候选人因为没有正确处理连续删除情况而被淘汰。一个看似简单的链表问题，往往能反映出程序员对指针操作的深刻理解程度。建议在准备面试时，至少手写3遍这个问题的完整实现，确保对各种边界条件都能正确处理。