深入解析CLRS项目中单链表与双链表的经典操作

深入解析CLRS项目中单链表与双链表的经典操作

CLRS 📚 Solutions to Introduction to Algorithms Third Edition 项目地址: https://gitcode.com/gh_mirrors/clr/CLRS

本文基于walkccc/CLRS项目中的第10章第2节内容，深入讲解单链表和双链表的各种基础操作实现及其时间复杂度分析。我们将从链表的基本操作入手，逐步探讨如何用链表实现栈、队列等数据结构，最后还会介绍一种巧妙的内存优化双链表实现方式。

单链表基础操作

常数时间插入操作

在单链表中实现O(1)时间的INSERT操作非常简单，只需要将新节点插入到链表头部即可：

LIST-INSERT(L, x)
    x.next = L.head
    L.head = x

这种头插法的时间复杂度确实是O(1)，因为它不依赖于链表的长度，无论链表中有多少元素，插入操作都只需要修改两个指针。

删除操作的优化

单链表的DELETE操作通常需要O(n)时间，因为需要找到待删除节点的前驱节点。但有一种巧妙的优化方法可以实现O(1)时间的"伪删除"：

1. 将后继节点的值复制到当前节点
2. 删除后继节点

LIST-DELETE-OPT(L, x)
    if x.next != NIL
        x.key = x.next.key
        x.next = x.next.next

这种方法虽然时间复杂度是O(1)，但有两个限制：

1. 不能删除最后一个节点
2. 当节点存储的是大对象时，复制操作代价很高

用单链表实现栈

栈是一种LIFO(后进先出)数据结构，使用单链表可以非常高效地实现：

PUSH(L, x)
    x.next = L.head
    L.head = x

POP(L)
    if L.head == NIL
        error "underflow"
    x = L.head
    L.head = L.head.next
    return x

两种操作的时间复杂度都是O(1)，因为都只涉及链表头部的操作。

用单链表实现队列

队列是FIFO(先进先出)结构，用单链表实现时需要维护头尾指针：

ENQUEUE(L, x)
    x.next = NIL
    if L.head == NIL
        L.head = x
    else
        L.tail.next = x
    L.tail = x

DEQUEUE(L)
    if L.head == NIL
        error "underflow"
    x = L.head
    L.head = L.head.next
    if L.head == NIL
        L.tail = NIL
    return x

入队操作需要处理链表尾部，而出队操作处理链表头部，两者时间复杂度均为O(1)。

链表搜索优化

常规的链表搜索需要两个条件判断：

LIST-SEARCH(L, k)
    x = L.head
    while x != NIL and x.key != k
        x = x.next
    return x

可以通过设置哨兵节点来消除对x != NIL的判断：

LIST-SEARCH-OPT(L, k)
    L.nil.key = k  // 设置哨兵节点的key
    x = L.nil.next
    while x.key != k
        x = x.next
    return x

当搜索失败时，循环会在x指向哨兵节点时终止，因为哨兵节点的key被设置为搜索值k。

双链表的异或指针优化

传统双链表每个节点需要存储prev和next两个指针。有一种巧妙的内存优化方法，只使用一个指针空间存储两个指针的异或值：

x.np = x.prev XOR x.next

遍历操作

要从头到尾遍历这种特殊双链表：

LIST-TRAVERSE(L)
    prev = NIL
    curr = L.head
    while curr != NIL
        next = prev XOR curr.np
        // 处理当前节点curr
        prev = curr
        curr = next

插入操作

在链表尾部插入新节点：

LIST-INSERT-XOR(L, x)
    x.np = L.tail XOR NIL
    if L.tail != NIL
        L.tail.np = (L.tail.np XOR NIL) XOR x
    if L.head == NIL
        L.head = x
    L.tail = x

反转操作

这种双链表的反转操作可以在O(1)时间内完成，只需交换头尾指针：

LIST-REVERSE-XOR(L)
    temp = L.head
    L.head = L.tail
    L.tail = temp

链表合并操作

对于两个不相交的双链表，可以在O(1)时间内合并它们：

LIST-UNION(L1, L2)
    L1.tail.next = L2.head
    L2.head.prev = L1.tail
    L1.tail = L2.tail

如果使用带哨兵的双链表实现，需要额外处理哨兵节点。

总结

本文详细讲解了CLRS项目中关于链表的各种经典操作实现，包括：

1. 单链表的基础插入删除操作
2. 用单链表实现栈和队列
3. 链表搜索的优化技巧
4. 双链表的内存优化实现
5. 链表的高效合并操作

理解这些基础操作的实现原理和时间复杂度分析，对于掌握更复杂的数据结构和算法至关重要。链表作为基础数据结构，其灵活性和高效性使其在算法设计中占有重要地位。

CLRS 📚 Solutions to Introduction to Algorithms Third Edition 项目地址: https://gitcode.com/gh_mirrors/clr/CLRS