单链表实现与yxc风格解析：数组模拟与核心操作

1. 单链表基础与yxc实现风格解析

第一次接触单链表是在大学数据结构课上，当时被指针跳转绕得头晕。直到后来看到acwing创始人yxc的实现方式，才真正理解如何用最精简的代码处理链式结构。这种实现方式把内存操作抽象成数组模拟，对新手特别友好。

单链表作为链式结构的入门款，核心在于理解节点间的引用关系。每个节点包含数据域和指针域，像一列首尾相连的火车车厢。yxc在acwing课程中演示的数组模拟法，实际上是用两个数组分别存储节点值和下一个节点的位置索引，这种实现方式比传统指针更直观，尤其适合算法竞赛场景。

2. 单链表的核心操作实现

2.1 基础结构定义

先看最基础的存储结构。在yxc的实现中，通常这样定义：

cpp复制const int N = 100010;
int head, idx;  // 头指针和当前可用索引
int e[N], ne[N]; // 值数组和next指针数组

void init() {
    head = -1;
    idx = 0;
}

这里用e[]存储节点值，ne[]存储下一个节点的位置。head初始为-1表示空链表，idx从0开始分配，这种模拟方式完全避免了指针操作。

2.2 头插法操作

在链表头部插入新节点是最基础的操作：

cpp复制void add_to_head(int x) {
    e[idx] = x;
    ne[idx] = head;
    head = idx++;
}

三步操作完成插入：1)存储值 2)新节点指向原头节点 3)更新头指针。时间复杂度O(1)，这种实现比传统指针写法简洁得多。

2.3 指定位置插入

在k节点后插入新节点的实现：

cpp复制void add(int k, int x) {
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx++;
}

注意这里的k是节点索引而非位置序号。操作顺序很重要：必须先让新节点指向k的后继，再修改k的next，否则会丢失链表信息。

3. 单链表的进阶操作

3.1 删除节点操作

删除k节点后的节点：

cpp复制void remove(int k) {
    ne[k] = ne[ne[k]];
}

看似简单的操作其实暗藏玄机。如果是删除头节点需要特殊处理：

cpp复制if (k == 0) {
    head = ne[head];
} else {
    ne[k-1] = ne[k];
}

3.2 链表遍历技巧

遍历链表的标准写法：

cpp复制for (int i = head; i != -1; i = ne[i]) {
    cout << e[i] << " ";
}

在算法题中，经常需要同时维护前驱指针。这时可以用双指针技巧：

cpp复制int prev = -1;
for (int curr = head; curr != -1; ) {
    if (满足某些条件) {
        // 处理节点
        if (prev == -1) head = ne[curr];
        else ne[prev] = ne[curr];
    } else {
        prev = curr;
    }
    curr = ne[curr];
}

4. 单链表的典型应用场景

4.1 邻接表存储图

在图的邻接表表示法中，单链表是标准实现：

cpp复制int h[N], e[M], ne[M], idx;

void add_edge(int a, int b) {
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

这种实现比vector更节省空间，特别适合稀疏图。注意链表的头指针数组h需要初始化为-1。

4.2 LRU缓存实现

单链表+哈希表可以实现O(1)的LRU缓存：

cpp复制struct Node {
    int key, val;
    int prev, next;
} nodes[N];

// 初始化双向链表
void init() {
    nodes[0].next = 1;
    nodes[1].prev = 0;
    idx = 2;
}

void remove_node(int k) {
    nodes[nodes[k].prev].next = nodes[k].next;
    nodes[nodes[k].next].prev = nodes[k].prev;
}

void add_to_head(int k) {
    nodes[k].next = nodes[0].next;
    nodes[k].prev = 0;
    nodes[nodes[0].next].prev = k;
    nodes[0].next = k;
}

虽然这里展示的是双向链表，但原理相通。yxc在acwing的算法课中详细讲解过这种实现。

5. 常见问题与调试技巧

5.1 内存越界问题

数组模拟法最常见的问题是索引越界。建议：

1. 初始化时检查数组大小是否足够
2. 操作前验证k是否合法
3. 在删除节点前检查ne[k]是否为-1

cpp复制if (k < 0 || k >= idx) return; // 非法索引
if (ne[k] == -1) return; // 已经是尾节点

5.2 链表成环检测

调试时可以在遍历中加入计数器：

cpp复制int count = 0;
for (int i = head; i != -1 && count < N; i = ne[i]) {
    count++;
    if (count == N) {
        // 检测到环
        break;
    }
}

5.3 可视化调试技巧

对于复杂操作，可以打印链表状态：

cpp复制void print_list() {
    cout << "head: " << head << endl;
    cout << "idx: " << idx << endl;
    for (int i = 0; i < idx; i++) {
        printf("node[%d]: val=%d next=%d\n", i, e[i], ne[i]);
    }
}

6. 单链表的扩展变种

6.1 带虚拟头节点的实现

在算法题中，经常使用虚拟头节点(dummy node)简化操作：

cpp复制void init() {
    head = 0;  // 虚拟头节点
    ne[head] = -1;
    idx = 1;
}

void add_to_head(int x) {
    add(0, x); // 统一使用add操作
}

这样所有节点都有前驱，无需特殊处理头节点。

6.2 静态链表内存池

对于频繁增删的场景，可以实现简单内存池：

cpp复制int pool[N], top;

void init_pool() {
    for (int i = 1; i < N; i++) {
        pool[top++] = i;
    }
}

int alloc_node() {
    return pool[--top];
}

void free_node(int k) {
    pool[top++] = k;
}

这种优化在ACM竞赛中很常见，yxc在高级算法课中专门讲解过。

7. 单链表算法题实战

7.1 链表反转的三种写法

最基础的反转写法：

cpp复制void reverse() {
    int prev = -1, curr = head;
    while (curr != -1) {
        int next = ne[curr];
        ne[curr] = prev;
        prev = curr;
        curr = next;
    }
    head = prev;
}

递归写法更简洁但可能栈溢出：

cpp复制int reverse_recursive(int curr, int prev) {
    if (curr == -1) return prev;
    int next = ne[curr];
    ne[curr] = prev;
    return reverse_recursive(next, curr);
}

7.2 快慢指针应用

检测环和找中点是一类经典问题：

cpp复制bool has_cycle() {
    int slow = head, fast = head;
    while (fast != -1 && ne[fast] != -1) {
        slow = ne[slow];
        fast = ne[ne[fast]];
        if (slow == fast) return true;
    }
    return false;
}

int find_mid() {
    int slow = head, fast = head;
    while (fast != -1 && ne[fast] != -1) {
        slow = ne[slow];
        fast = ne[ne[fast]];
    }
    return slow;
}

7.3 合并两个有序链表

归并排序的基础操作：

cpp复制int merge(int l1, int l2) {
    int dummy = idx++;
    int curr = dummy;
    while (l1 != -1 && l2 != -1) {
        if (e[l1] <= e[l2]) {
            ne[curr] = l1;
            l1 = ne[l1];
        } else {
            ne[curr] = l2;
            l2 = ne[l2];
        }
        curr = ne[curr];
    }
    ne[curr] = (l1 != -1) ? l1 : l2;
    return ne[dummy];
}

8. 性能优化与工程实践

8.1 缓存友好性优化

数组模拟法天然具有缓存局部性优势。进一步优化：

1. 节点数据紧凑存储
2. 预分配足够大内存
3. 批量操作时减少随机访问

cpp复制struct Node {
    int val;
    int next;
} nodes[N]; // 结构体数组更缓存友好

8.2 线程安全考虑

在多线程环境下，最简单的保护方式是：

cpp复制std::mutex mtx;

void safe_insert(int k, int x) {
    std::lock_guard<std::mutex> lock(mtx);
    add(k, x);
}

但更好的做法是使用无锁数据结构，这超出了单链表的基础范畴。

8.3 内存回收策略

对于长期运行的系统，需要实现内存回收：

cpp复制void remove_and_free(int k) {
    int to_free = ne[k];
    ne[k] = ne[ne[k]];
    free_node(to_free);
}

在算法竞赛中通常不需要，因为测试用例执行时间短。