单链表六大经典算法详解与实战应用

sched yield

1. 单链表应用实战：六大经典算法详解

单链表作为数据结构中最基础也最重要的线性结构之一，在算法面试和实际开发中都有着广泛应用。今天我将结合自己多年的开发经验，为大家详细解析单链表的六大经典算法问题，包括思路分析、代码实现和常见陷阱。这些内容不仅适合准备面试的同学，对日常开发中的链表操作也有很强的参考价值。

2. 六大单链表经典算法解析

2.1 移除链表元素问题

问题描述：给定一个链表头节点和一个整数值，删除链表中所有值等于给定值的节点，返回新的头节点。

核心思路：

三指针法：使用prev、pcur、next三个指针遍历链表
- 当pcur指向要删除的节点时，prev->next指向next，然后释放pcur
- 时间复杂度O(n)，空间复杂度O(1)
尾插法：创建新链表，将不需要删除的节点尾插到新链表
- 优势：逻辑清晰，不易出错
- 注意：最后需要将尾节点的next置NULL

代码实现关键点：

c复制struct ListNode* removeElements(struct ListNode* head, int val) {
    ListNode* newHead = NULL, *newTail = NULL;
    ListNode* pcur = head;
    while(pcur) {
        if(pcur->val != val) {
            if(!newHead) {
                newHead = newTail = pcur;
            } else {
                newTail->next = pcur;
                newTail = pcur;
            }
        }
        pcur = pcur->next;
    }
    if(newTail) newTail->next = NULL;  // 关键步骤
    return newHead;
}

常见错误：

忘记处理尾节点的next指针，导致链表不完整
没有考虑头节点就是要删除的情况
内存泄漏：删除节点后忘记释放内存

2.2 反转链表问题

问题描述：将单链表的所有节点反转，返回反转后的头节点。

两种经典解法：

头插法：
- 创建新链表，将原链表节点依次头插
- 直观易懂，但需要额外空间
三指针法（推荐）：
- 使用n1、n2、n3三个指针原地反转
- 时间复杂度O(n)，空间复杂度O(1)

三指针法实现细节：

c复制struct ListNode* reverseList(struct ListNode* head) {
    if(!head) return head;
    ListNode *n1 = NULL, *n2 = head, *n3 = head->next;
    while(n2) {
        n2->next = n1;  // 反转指针
        n1 = n2;
        n2 = n3;
        if(n3) n3 = n3->next;  // 边界检查
    }
    return n1;
}

注意事项：

处理空链表特殊情况
n3移动前必须检查是否为NULL
循环终止条件是n2为NULL

2.3 链表的中间节点问题

问题描述：找到单链表的中间节点，如果有两个中间节点则返回第二个。

快慢指针法：

慢指针每次走1步，快指针每次走2步
当快指针到达末尾时，慢指针正好在中间
时间复杂度O(n)，空间复杂度O(1)

实现代码：

c复制struct ListNode* middleNode(struct ListNode* head) {
    ListNode *slow = head, *fast = head;
    while(fast && fast->next) {  // 关键条件
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

易错点：

while循环条件顺序不能颠倒（必须先检查fast）
对于偶数长度链表，slow会停在第二个中间节点

2.4 合并两个有序链表

问题描述：将两个升序链表合并为一个新的升序链表。

尾插法实现：

比较两个链表当前节点值
将较小者尾插到新链表
当一个链表遍历完后，将另一个链表剩余部分直接连接

优化技巧：
使用哨兵节点(dummy node)简化代码：

c复制struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    ListNode dummy = {0, NULL};  // 哨兵节点
    ListNode *tail = &dummy;
    
    while(l1 && l2) {
        if(l1->val < l2->val) {
            tail->next = l1;
            l1 = l1->next;
        } else {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }
    tail->next = l1 ? l1 : l2;  // 连接剩余部分
    return dummy.next;
}

性能考虑：

不需要创建新节点，直接重用原链表节点
时间复杂度O(m+n)，空间复杂度O(1)

2.5 环形链表的约瑟夫问题

问题描述：n个人围成一圈，从第1个人开始报数，数到m的人出局，最后剩下的人的编号。

环形链表解法：

创建包含n个节点的环形链表
遍历链表计数，删除第m个节点
重复直到只剩一个节点

关键实现：

c复制typedef struct ListNode ListNode;

ListNode* createCircle(int n) {
    ListNode *head = malloc(sizeof(ListNode));
    head->val = 1;
    ListNode *tail = head;
    
    for(int i = 2; i <= n; i++) {
        tail->next = malloc(sizeof(ListNode));
        tail = tail->next;
        tail->val = i;
    }
    tail->next = head;  // 成环
    return tail;  // 返回尾节点便于操作
}

int ysf(int n, int m) {
    ListNode *prev = createCircle(n);
    ListNode *curr = prev->next;
    int count = 1;
    
    while(curr->next != curr) {
        if(count == m) {
            prev->next = curr->next;
            free(curr);
            curr = prev->next;
            count = 1;
        } else {
            prev = curr;
            curr = curr->next;
            count++;
        }
    }
    int res = curr->val;
    free(curr);
    return res;
}

注意事项：

内存管理：记得释放被删除的节点
边界条件：n=1时的特殊情况
数学解法更高效（O(n)时间，O(1)空间），但链表解法更直观

2.6 分割链表问题

问题描述：给定一个链表和值x，将所有小于x的节点排在大于等于x的节点之前。

大小链表法：

创建两个哨兵节点：lessHead和greaterHead
遍历原链表，节点根据值插入对应链表
最后连接两个链表

实现代码：

c复制struct ListNode* partition(struct ListNode* head, int x) {
    ListNode lessDummy = {0, NULL}, greaterDummy = {0, NULL};
    ListNode *lessTail = &lessDummy, *greaterTail = &greaterDummy;
    
    while(head) {
        if(head->val < x) {
            lessTail->next = head;
            lessTail = lessTail->next;
        } else {
            greaterTail->next = head;
            greaterTail = greaterTail->next;
        }
        head = head->next;
    }
    
    greaterTail->next = NULL;  // 避免循环
    lessTail->next = greaterDummy.next;
    return lessDummy.next;
}