从缓存的角度看链表与线性表的差异

顺序表读得快、链表读得慢：CPU 缓存与局部性原理

结论背得再熟，也不如看清机制。这节课把课件对比表里"缓存利用率：高 vs 低"这五个字，拆开讲透。

为什么需要

把顺序表和链表摆在同一张对比表里时，多数行一眼就能看懂：物理是否连续、随机访问是 O(1) 还是 O(N)、任意位置插入删除要不要搬移元素。唯独最后一行写着"缓存利用率：高 vs 低"，备注一行小字------参考存储体系结构与局部性原理。不少读者直接跳过。

跳过它，损失的不止一行结论。真实的工程场景里，顺序表和链表的差距几乎全在这一行：同样是遍历求和，顺序表能跑到同规模链表的数倍吞吐。复杂度上两者都是 O(N)，理论无法解释这个差距；能解释它的，是 CPU 访问内存的物理行为。这篇把机制讲透，之后有人问"为什么顺序表快"，就能从存储体系一路答到缓存行------这也正是课件备注想引导我们去的地方。要记住这条结论，更要答得出背后的"为什么"，否则面试里一追问就露怯。

存储体系：CPU 比内存快得离谱

计算机的存储是个金字塔结构（课件此处配了经典金字塔图，可对照原图查看）：

层级	速度	容量	是否断电丢失
寄存器	最快	极小（几十个）	是
高速缓存 L1/L2/L3	快	数十 KB ~ 数十 MB	是
内存	慢	GB 级	是
硬盘	最慢	大	否

自上而下，速度越来越慢、容量越来越大、单位成本越来越低。内存靠带电维持数据，断电即失，所以需要持久化的数据交给不带电的硬盘保存。

关键矛盾在中间两层。CPU 完成一次运算的时间，比内存响应一次访问快了约两个数量级。若 CPU 每次都干等内存，加法器大部分时间在空转。于是硬件加了两个缓冲：小而快的寄存器，大而较快的多级缓存。现代 CPU 通常多核，每个核拥有私有的 L1/L2，L3 被多核共享；核一多，同一块数据可能同时出现在多个核里，就有了"缓存一致性"（Cache Coherence）这个复杂问题。它超出本文范围，但你要知道它存在。

举课堂上的例子。执行 i++ 时，CPU 不会直接在内存里改 i，流程是：把 i 从内存读进寄存器，在加法器里完成加一，再把结果写回内存。中间这一步搬运，就是因为寄存器比内存快得多。顺带一提：前置 ++i 与后置 i++ 在不使用返回值时，编译出的汇编基本一致，真正的差别只在是否保存旧值用于返回------课堂引入这个例子只是为了引出寄存器，并非要深究自增的底层。

缓存行与局部性：一次搬运一整段

CPU 访问内存，不是需要 4 字节就只读 4 字节。它把目标地址附近一整段都搬进缓存，一次搬多少，取决于缓存行（Cache Line）大小------主流 x86 常见 64 字节。课堂有个贴切的大巴车比喻：

大巴有 30 个座位，管理员点名只叫 1 号同学。司机心想：反正跑一趟成本固定，你叫 1 号，我就把 1 到 30 号全捎上。等会儿你若叫 2 号 3 号，座位都在车上，不用再跑第二趟。

CPU 的硬件预取逻辑同理，它笃定你访问了当前位置，很可能接着访问相邻位置。这个假设背后是局部性原理（Principle of Locality）：程序在一段时间内的访问，倾向于集中在较窄的地址范围内。

由此得到两个术语：访问的数据已在缓存中、直接取用，叫缓存命中（Hit）；不在缓存中、得先从内存搬进缓存再访问，叫缓存未命中（Miss）。命中与否，决定这次访问是几纳秒还是上百纳秒。

代码演示：连续地址 vs 离散节点

顺序表和链表在物理存储上的差别，用地址说话最直观。

#include <stdio.h>
#include <stdlib.h>

typedef struct Node
{
    int data;
    struct Node* next;
} Node;

int main(void)
{
    // 顺序表：一段连续内存，这里直接放在栈上
    int seq[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };

    // 链表：每个节点独立申请，物理位置由堆的分配状况决定
    Node* head = NULL;
    for (int i = 0; i < 8; i++)
    {
        Node* p = (Node*)malloc(sizeof(Node));
        if (p == NULL)
            exit(EXIT_FAILURE);
        p->data = i;
        p->next = head;   // 头插
        head = p;
    }

    printf("顺序表（数组）元素地址：\n");
    for (int i = 0; i < 8; i++)
        printf("  seq[%d] @ %p\n", i, (void*)&seq[i]);

    printf("链表节点地址：\n");
    for (Node* cur = head; cur != NULL; cur = cur->next)
        printf("  %d @ %p\n", cur->data, (void*)cur);

    // 逐个释放，先记下 next 再 free，避免断链
    Node* p = head;
    while (p != NULL)
    {
        Node* tmp = p->next;
        free(p);
        p = tmp;
    }
    return 0;
}

机器上跑一次：数组 8 个地址是 ...c0、...c4、...c8......间隔恰好 4 字节（一个 int），首尾相连；链表 8 个节点则散落在堆的各处，next 把地址毫无规律的数据串成一条逻辑上的链。连续与离散，一目了然。

再看两种数据结构的访问逻辑（只写核心循环）：

// 顺序表：下标递增、地址连续，一次未命中载入的缓存行覆盖后续元素
long sum = 0;
for (size_t i = 0; i < n; i++)
    sum += seq[i];

链表版的核心循环长这样：

// 链表：沿 next 跳跃，落到哪个地址完全看节点当初分配在哪
long sum = 0;
for (Node* cur = head; cur != NULL; cur = cur->next)
    sum += cur->data;

把两种访问串成缓存事件序列，差异立刻浮现。顺序表读 0 号元素时第一次未命中，硬件顺手把 0 号附近一整行（约 64 字节，约 16 个 int）载入缓存；接着读 1、2、3...... 全部命中，直到走出这一行才触发下一次未命中。命中率高，载入的缓存行几乎全被用上。

链表相反：第一次访问头节点未命中，硬件同样载入一整行------但这一行装的是与头节点地址相邻的"邻居"，和链表的下一个节点毫无关系。下一次沿 next 跳走，十有八九又未命中，又载入一整行无用邻居。几乎每次访问都在未命中。

缓存污染：链表慢的真正原因

未命中本身已经够慢，更糟的是它的连锁反应：每次未命中都会把一整段"我们根本不需要的邻居数据"塞进缓存。缓存容量有限，塞不下时就要腾地方，主流策略近似 LRU（Least Recently Used，最近最少使用）------优先淘汰最久没被访问的行。

于是恶性循环出现：链表未命中时载入的无用行，会挤走缓存里可能还有用的数据。比如顺序表算法刚建立起来的缓存行，可能被链表的一次离散访问冲掉。这种无用数据占用并驱逐有效数据的现象，叫缓存污染（Cache Pollution）。

缓存行只有这么多。放进去的数据用不上，迟早用得上的数据被挤走------系统里最怕的，是让垃圾占着好位置。

	顺序表	链表
元素在内存中	物理连续	逻辑连续、物理分散
一次未命中之后	行内后续元素大概率命中	下一节点大概率仍不命中
未命中的副作用	载入的是即将用到的数据	载入无用邻居，产生缓存污染
遍历缓存表现	高命中率	高未命中率 + 污染

这解释了课件对比表那一行：存储连续 + 局部性原理，让顺序表的缓存利用率高；链表物理离散，缓存利用率低。也印证了工程里的经验法则：读多写少、以遍历和随机访问为主，选顺序表；频繁在任意位置插入删除、且遍历为辅，才轮到链表。

常见误区

1. "遍历都是 O(N)，顺序表和链表性能差不多。" 复杂度衡量的是操作次数随规模增长的阶，不是真实耗时。两者同为 O(N)，但顺序表命中率高，链表几乎次次未命中还叠加缓存污染，常数因子差出数倍。复杂度没有骗人，只是没说全。
2. 顺序表扩容后，要不要手动 free 旧指针？ 动态顺序表增容用 realloc：原地能扩就直接扩；扩不了就另找一块更大的空间、把数据拷过去并释放旧空间，然后返回新地址。释放旧空间这步 realloc 内部已处理，开发者只认它返回的那一个指针即可。再手动 free 旧指针，就是重复释放。记住：扩容后，只信 realloc 的返回值。
3. "缓存是软件层面的优化，写代码时不用管。" 缓存行的加载是硬件行为，程序关不掉它，只能顺应它。让数据在内存中尽量连续，是免费的性能。现代语言容器的遍历性能差异也源于此------例如 C++ 中 std::vector 普遍快于 std::list。

本节要点

• 存储体系呈金字塔：寄存器 → 缓存 → 内存 → 硬盘，速度递减、容量递增；CPU 直接等内存会浪费约两个数量级的时间。
• CPU 以缓存行为单位批量搬运内存，主流约 64 字节；敢一次预取一整段，依据是局部性原理。
• 数据已在缓存即命中，否则未命中、需先从内存载入------顺序表连续存储换来高命中率，链表离散导致几乎次次未命中。
• 链表未命中会把无用邻居载入缓存、按 LRU 挤走有用行，形成缓存污染，这是它遍历慢的深层原因。
• 选型结论不变：频繁遍历、随机访问用顺序表；任意位置插入删除频繁才用链表。"缓存利用率高/低"五个字背后，是整套存储体系。

---