链表基础操作：移除元素与反转链表详解-代码聚汇网

链表基础操作：移除元素与反转链表详解

陆拾贰號

1. 链表基础与问题概述

链表作为数据结构中的经典类型，在实际编程面试和算法题中出现的频率极高。最近我在刷LeetCode时，发现203题"移除链表元素"和206题"反转链表"这两道题目虽然都属于链表基础操作，但在指针处理上却有着微妙的差异。今天我就结合自己的解题经验，详细分析这两道题的解题思路和实现细节。

链表与数组最大的区别在于其非连续存储的特性。每个节点包含数据和指向下一个节点的指针，这种结构使得插入和删除操作的时间复杂度可以达到O(1)，但同时也带来了遍历和访问上的复杂性。理解指针的操作是掌握链表问题的关键。

2. 移除链表元素详解

2.1 问题分析与基础解法

题目要求删除链表中所有值等于给定val的节点，并返回新的头节点。最直观的思路就是遍历链表，遇到目标节点就跳过它。

基础解法可以使用单指针：

python复制def removeElements(head, val):
    # 处理头节点就是要删除的情况
    while head and head.val == val:
        head = head.next
    
    current = head
    while current and current.next:
        if current.next.val == val:
            current.next = current.next.next
        else:
            current = current.next
    return head

这种方法虽然直接，但需要单独处理头节点可能被删除的情况，代码看起来不够优雅。

2.2 虚拟头节点技巧

更优雅的解决方案是引入虚拟头节点(dummy node)：

python复制def removeElements(head, val):
    dummy = ListNode(0, head)  # 创建虚拟头节点
    current = dummy
    
    while current.next:
        if current.next.val == val:
            current.next = current.next.next
        else:
            current = current.next
    
    return dummy.next  # 返回真实头节点

虚拟头节点的优势：

统一处理逻辑，不需要单独考虑头节点
代码更简洁，减少边界条件判断
时间复杂度仍为O(n)，空间复杂度O(1)

注意：使用虚拟头节点后，最后返回的是dummy.next而不是dummy本身，这是一个常见的易错点。

2.3 递归解法分析

除了迭代法，这个问题也可以用递归解决：

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

递归解法的特点：

代码更简洁
但空间复杂度为O(n)（调用栈空间）
对于长链表可能导致栈溢出

在实际面试中，迭代法通常是更安全的选择。

3. 反转链表深入解析

3.1 迭代法实现

反转链表是更复杂的操作，需要改变节点的指向关系。最基本的迭代法使用双指针：

python复制def reverseList(head):
    prev = None
    current = head
    
    while current:
        next_node = current.next  # 临时保存下一个节点
        current.next = prev       # 反转指向
        prev = current            # 移动prev指针
        current = next_node       # 移动current指针
    
    return prev  # 最后prev成为新的头节点

关键点：

必须先用临时变量保存current.next，否则反转后无法访问原下一个节点
指针移动顺序很重要：先保存next，再反转，最后移动指针
循环结束时，prev指向原链表的最后一个节点，即反转后的头节点

3.2 递归解法探究

反转链表也可以用递归实现：

python复制def reverseList(head):
    if not head or not head.next:
        return head
    
    new_head = reverseList(head.next)
    head.next.next = head  # 反转指向
    head.next = None       # 断开原指向
    
    return new_head

递归解法的特点：

代码简洁但较难理解
从链表尾部开始反转
同样有O(n)的空间复杂度

3.3 常见错误分析

在实现反转链表时，容易犯以下错误：

丢失节点引用：

python复制# 错误示例
current.next = prev
current = current.next  # 此时current.next已经是prev了，会丢失原下一个节点

循环引用：

python复制# 错误示例
next_node = current.next
current.next = prev
prev = current
current = current.next  # 错误！应该用保存的next_node

边界条件处理不当：

空链表
单节点链表
没有正确更新头节点

4. 两种操作的对比与总结

4.1 指针操作的本质区别

移除元素和反转链表的根本区别在于是否改变节点的指向关系：

操作类型	指针变化	是否需要临时保存	时间复杂度	空间复杂度
移除元素	不改变原有指向	不需要	O(n)	O(1)
反转链表	改变节点指向	需要	O(n)	O(1)

在移除元素时，我们只是"跳过"某些节点，不改变原有链表的指向关系，因此可以直接使用p.next.next这样的访问方式。而在反转链表时，改变节点的next指针会破坏原有的遍历路径，必须提前保存下一个节点的引用。

4.2 选择合适的方法

对于这类链表操作问题，选择实现方法时需要考虑：

迭代 vs 递归：
- 迭代法通常更高效（空间复杂度O(1)）
- 递归法代码更简洁但可能有栈溢出风险
虚拟头节点的使用：
- 当需要统一处理头节点和其他节点时很有用
- 会增加少量空间开销
指针数量的选择：
- 单指针：适用于简单遍历
- 双指针：适用于需要前后参照的情况
- 三指针：更复杂的操作，但可能增加复杂度

4.3 实战技巧

画图辅助：在纸上画出链表和指针变化，可以更直观理解操作过程
逐步调试：对于复杂指针操作，可以逐步跟踪变量值
边界测试：特别注意空链表、单节点链表等边界情况
复杂度分析：明确时间和空间复杂度要求，选择合适算法

在实际面试中，建议：

先解释思路，再写代码
讨论不同解法的优缺点
主动考虑边界条件
写完后进行简单测试

链表操作是算法基础中的重点，掌握这些核心问题的解法后，可以更容易应对更复杂的链表问题，如环形链表检测、合并有序链表、重排链表等。关键是多练习，培养对指针操作的直觉。