1. 链表基础操作全解析
链表作为数据结构中的经典类型，在实际开发中有着广泛应用。今天我想系统梳理一下链表相关的六大核心操作，包括基础的元素移除、链表设计，以及进阶的翻转、结点交换、倒数删除和环形检测。这些操作不仅是面试中的高频考点，更是日常开发中处理链式数据的必备技能。
2. 移除链表元素
2.1 问题定义与解法思路
给定一个链表和一个目标值，要求删除链表中所有值等于目标值的节点。例如输入：1->2->6->3->4->5->6，目标值6，输出应为1->2->3->4->5。
这个问题的关键在于处理头节点和连续出现目标值的情况。我通常会采用虚拟头节点(dummy node)的技巧来简化操作，这样就不需要单独处理头节点被删除的特殊情况。
2.2 具体实现步骤
python复制def removeElements(head, val):
dummy = ListNode(0) # 创建虚拟头节点
dummy.next = head
current = dummy
while current.next:
if current.next.val == val:
current.next = current.next.next # 跳过目标节点
else:
current = current.next # 正常移动指针
return dummy.next # 返回真实头节点
注意：在Python中需要特别注意节点的引用关系，避免内存泄漏。实际操作中，被删除的节点如果没有其他引用会被自动回收。
2.3 复杂度分析与优化
时间复杂度O(n)，空间复杂度O(1)。这个解法已经是最优解，但可以尝试递归实现作为练习：
python复制def removeElementsRecursive(head, val):
if not head:
return None
head.next = removeElementsRecursive(head.next, val)
return head.next if head.val == val else head
3. 设计链表
3.1 链表ADT的基本要素
一个完整的链表抽象数据类型(ADT)应该支持以下操作：
- 获取指定位置的元素
- 在头部/尾部添加元素
- 在指定位置添加元素
- 删除指定位置的元素
3.2 Python实现示例
python复制class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class MyLinkedList:
def __init__(self):
self.dummy = ListNode(0) # 虚拟头节点
self.size = 0
def get(self, index: int) -> int:
if index < 0 or index >= self.size:
return -1
current = self.dummy.next
for _ in range(index):
current = current.next
return current.val
def addAtHead(self, val: int) -> None:
self.addAtIndex(0, val)
def addAtTail(self, val: int) -> None:
self.addAtIndex(self.size, val)
def addAtIndex(self, index: int, val: int) -> None:
if index > self.size:
return
prev = self.dummy
for _ in range(index):
prev = prev.next
new_node = ListNode(val, prev.next)
prev.next = new_node
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
prev = self.dummy
for _ in range(index):
prev = prev.next
prev.next = prev.next.next
self.size -= 1
3.3 设计要点与陷阱
- 使用size变量记录链表长度可以避免每次计算
- 虚拟头节点统一了所有操作，简化边界条件处理
- 特别注意index的有效性检查
- 添加/删除操作后要及时更新size
4. 翻转链表
4.1 迭代法实现
翻转链表是理解指针操作的最佳练习题。迭代法的核心思想是维护三个指针：prev, current, next。
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 # 新的头节点
4.2 递归法实现
递归实现更加简洁，但需要理解递归的调用栈：
python复制def reverseListRecursive(head):
if not head or not head.next:
return head
new_head = reverseListRecursive(head.next)
head.next.next = head # 反转指针
head.next = None # 断开原指针
return new_head
4.3 应用场景
链表翻转在实际中有多种应用：
- 判断回文链表
- 特定区间内的链表翻转
- 两数相加问题中的数字顺序处理
5. 两两交换链表中的结点
5.1 问题描述
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。例如：1->2->3->4变为2->1->4->3。
5.2 迭代解法
python复制def swapPairs(head):
dummy = ListNode(0)
dummy.next = head
prev = dummy
while prev.next and prev.next.next:
first = prev.next
second = first.next
# 执行交换
prev.next = second
first.next = second.next
second.next = first
# 移动prev指针
prev = first
return dummy.next
5.3 递归解法
python复制def swapPairsRecursive(head):
if not head or not head.next:
return head
first = head
second = head.next
# 交换并递归处理剩余部分
first.next = swapPairsRecursive(second.next)
second.next = first
return second
提示：在处理链表问题时，画图辅助理解指针的变化非常有效。我习惯用不同颜色的笔标注各个指针的位置变化。
6. 删除链表的倒数第n个结点
6.1 双指针技巧
这个问题展示了快慢指针的强大之处。我们可以让快指针先走n步，然后两个指针一起移动，当快指针到达末尾时，慢指针正好指向要删除节点的前驱。
python复制def removeNthFromEnd(head, n):
dummy = ListNode(0)
dummy.next = head
fast = slow = dummy
# 快指针先走n步
for _ in range(n):
fast = fast.next
# 同时移动直到快指针到达末尾
while fast.next:
fast = fast.next
slow = slow.next
# 删除目标节点
slow.next = slow.next.next
return dummy.next
6.2 边界情况处理
需要特别注意的边界情况包括：
- 链表长度等于n（删除头节点）
- n大于链表长度
- 空链表
6.3 复杂度分析
时间复杂度O(L)，空间复杂度O(1)，其中L是链表长度。这是最优解法。
7. 环形链表检测
7.1 快慢指针算法
检测链表是否有环是经典问题，快慢指针(Floyd判圈算法)是最佳解决方案。
python复制def hasCycle(head):
if not head or not head.next:
return False
slow = head
fast = head.next
while slow != fast:
if not fast or not fast.next:
return False
slow = slow.next
fast = fast.next.next
return True
7.2 数学原理
快指针每次走两步，慢指针每次走一步。如果有环，它们必定会相遇，因为它们的相对速度是1步/次。这个结论可以通过模运算严格证明。
7.3 进阶问题：找出环的入口
在检测到环后，可以将一个指针移回起点，然后两个指针以相同速度前进，再次相遇点就是环的入口。这是Floyd算法的扩展应用。
python复制def detectCycle(head):
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast: # 相遇点
slow = head
while slow != fast:
slow = slow.next
fast = fast.next
return slow
return None
8. 综合应用与实战技巧
8.1 链表问题的通用解法
- 虚拟头节点：简化边界条件处理
- 双指针技巧：解决环检测、倒数第n个等问题
- 递归思想：简化复杂操作
- 画图辅助：理清指针变化
8.2 调试技巧
- 打印链表内容：实现一个辅助函数打印链表，方便调试
- 单元测试：为每个功能编写测试用例，特别是边界情况
- 内存管理：在C++等语言中要注意手动释放删除的节点
8.3 性能优化
- 避免不必要的遍历：合理使用缓存和指针
- 空间换时间：在允许的情况下可以使用哈希表存储节点
- 尾指针优化：如果需要频繁操作链表尾部，可以维护一个尾指针
在实际工程中，链表操作往往不是孤立的，需要结合具体场景选择最合适的实现方式。例如，在内存受限的环境中，递归解法可能不如迭代解法可靠；而在追求代码简洁的场景下，递归可能更有优势。