写链表代码这件事我面试过不少候选人也带过不少新人。Java 和 C 都写过链表的人通常对“指针”和“引用”的理解会透彻很多。链表的操作与实现看起来就是增删改查但里面藏着内存管理、边界条件、抽象设计这些真正的分水岭。这篇博客我想完整拆一遍从数组痛点出发为什么链表存在然后分别用 C 和 Java 实现单链表的核心操作再把环形链表、双向链表和几道高频面试题串起来最后分享一些只有实际写代码才会遇到的经验教训。无论是应付考试、准备面试还是想真正搞懂数据结构的底层机制这篇应该都能给你一个清晰的参照系。1. 为什么会有链表从数组的“排队长龙”说起每次讲链表我最开始都是从数组讲起。数组和链表是线性表的两大实现方式但很多人只知道“数组查得快、链表增删快”这句口诀不理解背后的根本原因导致一问变更底层就懵。1.1 数组的两个硬伤扩容和中间插入数组在内存里是一段连续的空间这带来两个连锁反应。第一是扩容代价高。我在 Java 里ArrayList满了之后要 grow 到 1.5 倍容量再把旧数组的元素一个个拷过去C 语言里用realloc如果原地空间不够同样要把数据搬到新地址。这个借数据的过程时间复杂度是 O(n)。数据量一大扩容那一下就会卡顿。第二是中间插入要“挪窝”。假设数组里有 10 个元素我想在 index 3 的位置插一个新元素那么原本 index 3 到 index 9 的所有元素都要往后挪一位。想象一下电影院一排座位已经坐满了现在来过道中间伸脚硬塞一个人后面所有人必须往一边挤。这个“集体挪动”也是 O(n) 操作。同理删除数组中间元素也会引发前移数组越大挪动成本越高。如果我们的程序大部分操作都是“在尾部追加”数组其实很高效。但一旦出现大量“在指定位置插入”“在头部插入”这种操作数组就会显得笨重。1.2 链表给出的方案让每个元素自带“导航指针”链表的思想完全不同。它不要求内存连续每个元素是一个独立的“结点”Node结点里存两个东西数据本身以及指向下一个结点的指针Java 里叫引用。这样一来链表天然解决了两件事扩容不需要。每次插入我只为这个新结点单独分配一块内存和已有的数据毫无关系。中间插入不需要挪动任何已有数据只要断开原来的连接把新结点接进去改两条指针关系就行。还是电影院比喻链表里的每个座位不是一排固定的椅子而是一群人手拉手排成队伍。新人来了站在两个人中间两边的人松开手、牵住新人就行后面的人根本不用动。1.3 带头结点与不带头结点的单链表热词里出现了“不带头结点的单链表”很多初学者在这块吃过亏。所谓“头结点”head node是指一个不存实际数据的额外结点它的作用是让头指针永远不空从而简化边界判断。带头结点时空链表不是NULL而是有一个 headhead 的 next 为 NULL。插入头部、插入尾部、删除节点代码逻辑可以统一处理不需要为“链表是否为空”单独写分支。不带头结点时头指针本身直接指向第一个数据结点空链表就是head NULL。此时如果要在头部插入必须修改头指针本身的值所以 C 语言里要传二级指针或者用返回值接收新的头指针Java 里虽然有引用传参但同样存在“引用本身传不回来”的问题。我个人的观点很明确日常练习和项目实现带头结点能省非常多的事。但你必须两种都理解因为很多教科书和面试题都以不带头结点为默认看不懂底层就很容易翻车。2. C 语言手写单链表指针与内存真相C 语言实现链表核心考验的是两件事指针怎么绕内存怎么还。我先给出完整结构体和操作再逐段讲每个操作背后的设计逻辑。2.1 结点定义与整体结构#include stdio.h #include stdlib.h #include stdbool.h typedef struct Node { int data; // 数据域这里以 int 为例 struct Node *next; // 指针域指向下一个结点 } Node;这里注意struct Node里包含了指向自身类型的指针。我们不能在结构体里直接包含一个Node类型的普通成员否则会无限嵌套、大小无穷大但包含指针没问题指针的大小是固定的64 位系统下 8 字节它只是存一个地址。单链表的完整操作我习惯分成这几组创建链表头插法、尾插法包括在指定位置插入的逻辑基础遍历与查找按值查找、按位置查找删除删除指定位置、删除指定值、清空链表销毁与内存回收2.2 创建结点与头插法Node* createNode(int data) { Node *newNode (Node*)malloc(sizeof(Node)); if (newNode NULL) { printf(内存分配失败\n); exit(EXIT_FAILURE); } newNode-data data; newNode-next NULL; return newNode; } // 带头结点的头插法 void insertAtHead(Node *head, int data) { Node *newNode createNode(data); newNode-next head-next; head-next newNode; }我见过很多初学者忘掉newNode-next head-next这一步直接把newNode-next head结果是彻底断链新结点后面的所有内容全丢了。正确顺序永远是先让新结点接住原来的首结点再让头结点指向新结点这两句顺序不能反。2.3 尾插法与在指定位置插入尾插法要维护一个尾指针不然每次都从头遍历到尾部时间复杂度表 O(n) 会变成 O(n²)。我在代码里一般用一个tail双指针方案void insertAtTail(Node *head, int data) { Node *tail head; while (tail-next ! NULL) { tail tail-next; } Node *newNode createNode(data); tail-next newNode; }这个版本每次调用都从头找尾部适合演示。工程上我会额外传Node **tail或者直接维护一个全局尾指针。在指定位置插入是链表操作里信息量最大的一个函数。热词里专门提到“在指定位置插入建立单链表”我就完整写一遍// 在第 pos 个位置插入pos 从 0 开始0 表示头结点后第一个数据位 bool insertAtPosition(Node *head, int pos, int data) { if (pos 0) return false; Node *prev head; int i 0; // 找第 pos 个结点的前驱 while (prev ! NULL i pos) { prev prev-next; i; } if (prev NULL) return false; // 位置超出链表长度 Node *newNode createNode(data); newNode-next prev-next; prev-next newNode; return true; }这里最关键的地方是我们要找的不是第 pos 个结点而是它的前驱结点。因为单链表是单向的你拿到当前结点后无法从它自身找到上一个结点也就无法修改上一个结点的 next 指针。想插入必须站在前驱的视角操作。这是单链表和双向链表最大的区别也是面试时画图最容易画错的地方。pos为何从 0 开始而不是从 1 开始我习惯叫position遵循“第 0 个数据结点”的下标语义和数组下标保持一致。如果你写的教材从 1 开始也可以但代码里判断和调用方式要对齐别混用。2.4 删除节点与内存释放bool deleteAtPosition(Node *head, int pos, int *deletedData) { if (pos 0) return false; Node *prev head; int i 0; while (prev-next ! NULL i pos) { prev prev-next; i; } if (prev-next NULL) return false; // 没有第 pos 个节点 Node *toBeDeleted prev-next; *deletedData toBeDeleted-data; // 把删掉的数据传出去 prev-next toBeDeleted-next; // 前驱直接指向被删节点的后继 free(toBeDeleted); // 释放节点内存 return true; }删除的核心思想同样是“站在前驱的角度”让前驱的 next 绕过被删节点直接指向它的后继。这里有个初学者最容易忽略的坑——删完节点之后有没有 free如果不 free每删一个节点就丢一块内存程序长时间运行后内存会持续增长这就是真正的内存泄漏memory leak。C 语言没有垃圾回收malloc和free必须成对出现。另一个重要细节free 之后要不要把toBeDeleted指针置 NULL严格说free只是释放了指针指向的那块内存指针变量的值地址还在。如果之后不小心访问了这个“悬空指针”dangling pointer就属于未定义行为undefined behavior可能崩溃可能读到垃圾数据甚至可能被攻击者利用。所以我在项目里有一条铁律free 之后立即将指针置为 NULL。销毁整个链表时最容易写错的版本是用head head-next; free(head)这种顺序结果剩下的一半节点成了孤儿。正确做法是先保存下一个节点地址再释放当前节点void destroyList(Node *head) { Node *current head-next; while (current ! NULL) { Node *temp current-next; // 先保存下一个 free(current); current temp; } // 如果需要连头结点一起释放最后 free(head) }2.5 遍历、反转与典型边界遍历链表void printList(Node *head) { Node *cur head-next; while (cur ! NULL) { printf(%d - , cur-data); cur cur-next; } printf(NULL\n); }迭代反转是面试常客也是理解指针操作最好的练习之一Node* reverseList(Node *head) { Node *prev NULL; Node *cur head-next; // 跳过带头节点开始 while (cur ! NULL) { Node *next cur-next; // 先保存后继 cur-next prev; // 当前节点指向前一个 prev cur; // prev 前进 cur next; // cur 前进 } head-next prev; // 重新挂回头节点 return head; }反转的思路一句话就能说清从头到尾让每个节点的 next 指向它的前驱。但执行顺序有个坑如果你先改了当前节点的 next就再也找不到原来的后继了。所以必须用临时变量先把下一个节点存下来这就是代码里next变量的作用。这个“先记录、再修改”的思路后面刷题还会无数次遇到。3. Java 版链表实现从对象引用到泛型设计Java 实现链表好消息是你不必手动管内存垃圾回收机制帮你还坏消息是 Java 没有“指针操作”这种直观语法初学者常常搞不懂“引用到底是个啥”。我的理解是这样Java 引用和 C 指针指向内存的底层机制基本相同只是你不允许做指针算术也不存在free。对象没人引用时会被垃圾回收器回收。3.1 一个干净的泛型实现我用 Java 自定义一个单链表核心要点有两个泛型和内部 Node 类。public class MyLinkedListE { // 内部类节点 private static class NodeE { E data; NodeE next; Node(E data) { this.data data; this.next null; } } private NodeE head; // 头结点带头节点简化边界 private int size; public MyLinkedList() { head new Node(null); // 带头节点的空链表 size 0; } public int size() { return size; } public boolean isEmpty() { return size 0; } }为什么要static内部类因为内部节点不需要访问外部类的实例字段。static让 Node 不隐式持有外部类的引用可以省内存也避免潜在的泄漏风险。这是个在面试里很加分的细节。Java 链表的核心操作和 C 版本逻辑几乎一样但有几处差异点必须特别注意比如删除时要判断泛型是否为 null后面专门说。3.2 add、remove、get 的完整实现// 尾插 public boolean add(E data) { NodeE cur head; while (cur.next ! null) { cur cur.next; } cur.next new Node(data); size; return true; } // 指定位置插入 public boolean add(int index, E data) { checkPositionIndex(index); NodeE prev head; for (int i 0; i index; i) { prev prev.next; } NodeE newNode new Node(data); newNode.next prev.next; prev.next newNode; size; return true; } // 删除指定位置 public E remove(int index) { checkElementIndex(index); NodeE prev head; for (int i 0; i index; i) { prev prev.next; } NodeE target prev.next; prev.next target.next; size--; target.next null; // 帮助 GC避免“老对象”仍持有引用 return target.data; } // 按索引取值 public E get(int index) { checkElementIndex(index); NodeE cur head.next; for (int i 0; i index; i) { cur cur.next; } return cur.data; }target.next null这行是很多 Java 程序员写链表时容易略过的。虽然 Java 有 GC但如果你不主动断开target对后一个节点的引用这个被删除的节点会连着后续整条链表造成一定程度的内存滞留实际 JVM 的垃圾收集器本质是可达性分析不主动置 null 最终也能回收取决于 JVM 实现但主动置 null 一方面能让对象更早可回收另一方面也让代码意图更明确。这是 JDK 源码里也会做的操作属于有经验的表现。3.3 为什么 Java 删除指定值要小心 null很多自写链表会提供remove(Object o)方法按照值删除。这时候必须处理o null的情形。public boolean remove(Object o) { NodeE prev head; while (prev.next ! null) { if (o null ? prev.next.data null : o.equals(prev.next.data)) { prev.next prev.next.next; size--; return true; } prev prev.next; } return false; }如果直接用o.equals(prev.next.data)当o为 null 时会抛出 NullPointerException如果直接用prev.next.data.equals(o)当节点数据为 null 时同样会崩。唯一稳妥的方式就是上面的三元表达式写法。看似一行小逻辑却是很多入行两三年的工程师都会犯的低级错误。3.4 Java 与 C 链表实现的核心差异对照很多人在两种语言切换时容易把习惯带串我用表格总结一下核心差异。维度C 语言Java节点连接方式指针存地址引用指向对象内存分配malloc / callocnew内存回收手动 freeGC 自动回收空节点表示NULLnull传递头指针修改需二级指针或用返回值引用本身不可变但对象内容可变溢出检查由程序员保证极易漏抛异常或返回 false数据泛化用 void* 或用宏定义容易丢类型信息泛型类型安全性能更接近机器无运行时开销有 JIT 优化但对象头开销更大我个人的经验是先用 C 把链表的“内在机制”搞通——指针怎么指、内存怎么收再用 Java 把“接口设计”做漂亮——泛型怎么定、异常怎么抛、边界怎么处理。两个语言都写完你对链表的理解才是完整的。4. 环形链表、双向链表与高频面试算法链表不止单链表一种形态。热词里有“循环单链表”也有“java面试题”说明很多人学链表是为了应对考试或面试。这一节我把变体和经典算法一起梳理。4.1 循环单链表从哪来往哪回循环单链表和单链表唯一的区别是最后一个结点的 next 不指向 NULL而是指回头结点或第一个数据结点。这样整个链表形成一个环遍历时不会自然地停在 NULL必须设置一个“终止条件”比如回到头结点就算走完一轮。循环链表的优势是从任意一个结点出发都能遍历全部链表在“约瑟夫环”这类需要循环报数的问题里非常自然。实现上插入、删除的核心和单链表相同只是判断结束的条件变了。构建循环单链表最简单的方式是尾插法结束后让最后一个节点 next 指向 headvoid makeCircular(Node *head) { Node *cur head; while (cur-next ! NULL) cur cur-next; cur-next head; // 形成环 }遍历时的条件从cur ! NULL变成cur ! headvoid printCircular(Node *head) { if (head NULL) return; Node *cur head-next; while (cur ! head) { printf(%d - , cur-data); cur cur-next; } printf((back to head)\n); }4.2 双向链表给每个节点来来回回的路双向链表Doubly Linked List在单链表基础上给每个节点增加一条prev指针指向前一个节点。代价是每个节点多一个指针内存收益是删除节点时不需要再找前驱而且可以高效地从后往前遍历。Java 里最典型的例子就是LinkedList它内部就是一个双向链表。删除某个已知节点时时间复杂度从单链表的 O(n) 下降到 O(1)前提是你能直接拿到该节点引用。双向链表插入节点同样需要注意顺序在 prev 与 next 之间插入 newNode 时newNode.prev prev newNode.next next prev.next newNode next.prev newNode这里有一个经典经验先更新 new 节点的两条指针再更新旧节点的两条指针。如果你先把 prev.next 改成了 newNode而 newNode.prev 还没设置好真实的链表就断了。4.3 高频面试题之一链表中环的检测“如何判断一条链表有环”是链表面试里出现频率极高的题。方案很多但最优解是快慢指针Floyd 判圈法维护slow和fast两个指针都从头走slow每次前进一步fast每次前进两步。如果链表无环fast最终会走到 NULL如果有环fast一定会在环内“追上”slow。public boolean hasCycle(Node head) { Node slow head, fast head; while (fast ! null fast.next ! null) { slow slow.next; fast fast.next.next; if (slow fast) return true; } return false; }很多人背这个答案但不知道为什么慢指针和快指针一定会在环内相遇。简单解释当 slow 进入环时假设 fast 在环内某处。slow 每走一步fast 走两步也就是说 fast 相对 slow 的速度是“每步多走一格”。可以理解为快指针以每次一格的速度逼近慢指针绕环一周的距离是有限的所以它不可能永远追不上。进阶版本还会让求“环入口”。这题的结论是相遇之后把 fast 拉回首然后快慢都以一步走再次相遇的位置就是环的入口。原理推导涉及公式计算建议画图推一遍胜过背代码。4.4 高频面试题之二合并两个有序链表与找中点合并两个有序链表是链表操作里逻辑最清晰也最考基本功的题public Node mergeTwoLists(Node l1, Node l2) { Node dummy new Node(-1); // 带头节点的方法在这里也适用 Node tail dummy; while (l1 ! null l2 ! null) { if (l1.data l2.data) { tail.next l1; l1 l1.next; } else { tail.next l2; l2 l2.next; } tail tail.next; } tail.next (l1 ! null) ? l1 : l2; return dummy.next; }这里dummy哑结点本质上就是带头结点的思路把“空链表怎么合并”这种边界问题统一掉不需要写特判。找有序链表的中点用快慢指针同样优雅slow走一步fast走两步当fast到尾部时slow正好在中点。拉直链表找中点再配上反转、合并就是归并排序核心步骤。建议学链表时把“快慢指针家族”整理成一个专题融会贯通。5. 实操避坑清单那些代码能跑但藏着雷的地方这一节把我的亲历经验集中写出来很多坑不是语法错误而是运行时的“慢性病”。代码一时能跑数据一多就露馅。5.1 C 语言最常见的四类事故第一忘记分配内存就赋值。有些初学者直接写Node *head; head-data xxx;但head没有指向任何合法内存这是典型的野指针操作程序崩溃是大概率事件。任何节点使用前必须malloc。第二遍历临界条件写错。链表题最经典的错误是把while (cur ! NULL)写成while (cur-next ! NULL)导致丢失最后一个节点。建议每次遍历前先在草稿上画三个节点空链表、单节点、多节点三种情况都过一遍。第三删除节点不保存后继。前面反转里说过一旦你先动了 next后面的节点全部找不回来。这几乎是每个新手都会犯的错我现在带人时第一要求就是任何修改 next 的操作之前先问自己原来的后继我能不能再拿到第四头指针被修改后调用方不知道。在不带头结点的情况下头部插入/删除会改变头指针本身C 语言函数参数传递是值传递你直接改形参外面的头指针不变。解决方案要么传二级指针Node **head要么用返回值传递新头指针。这个坑在 C 语言面试判断题里几乎必然出现。5.2 Java三个隐蔽的设计问题第一size 维护不一致。自写链表最容易产生的问题是 add 和 remove 里漏掉 size 的更新。插入时 size删除时 size--务必成对。我见过有同学只在一个函数里维护 size另一个函数忘了改结果get(size-1)直接越界。第二索引校验不一致。add(index) 和 remove(index) 的校验方式不同。add 时 index 可以等于 size在末尾添加remove 时 index 必须小于 size。我习惯把校验拆成两个私有方法checkPositionIndex和checkElementIndex语义清楚也不容易混乱。第三遍历时用 for 循环而不是 while。推荐下面这种写法更少犯错for (NodeE cur head.next; cur ! null; cur cur.next) { // 处理 cur.data }for 循环把游标的初始化、条件和前进全部集中在一行不容易漏掉cur cur.next。如果有人用 while 却忘了在循环体末尾前进指针就会死循环。5.3 调试链表问题的核心方法画图和打印我见过很多人调试链表问题时靠单步断点硬走跑到一半就晕了。调试链表最高效的方法是先把链表画成箭头图。复杂一点的题比如反转、插入、合并我强烈建议在纸上画出如下三种状态操作前的链表状态每一步指针修改后的中间状态最终状态每一步操作都对照图来检查代码哪里断了链一目了然。另外写一个printList辅助函数会事半功倍在关键操作后打印整条链表能立刻看到断链发生在哪个节点。我自己还有一个土办法给节点编号或者把节点的data和一段随机后缀打印出来比如[data:3, addr:0x7f]。这样你能明确知道某个节点是不是被你弄丢了。提示链表代码的很多 bug 都和“三个状态”有关——空链表、只有一个元素的链表、删除最后一个元素。无论你写什么链表操作开发测试用例时这三个场景必须覆盖。6. 链表和数组的选择不止是“查快增删慢”前面讲了很多实现细节最后回到设计层面。作为工程师你得知道什么时候该用链表什么时候不要用链表否则容易陷入“拿着锤子看什么都是钉子”。链表确实在“频繁在头部/中间插入删除”的场景下有结构性优势但它也有明显代价节点存储额外指针内存空间开销更大每个节点单独分配内存碎片化更严重缓存局部性差链表不支持随机访问每次查找都要从头走Java 里节点对象本身和引用字段的额外对象头开销比数组大得多所以放到工程里很多自称“需要频繁插入”的场景实测用 ArrayList 反而更快。原因是当操作都在尾部时数组扩容带来的 O(n) 摊销后性能非常高而且连续内存的缓存命中率远高于散落指针。真正的经验是先分析你的插入位置是头部、中间还是尾部再分析你的读操作是不是随机访问。如果随机读多优先数组如果在中间插入极频繁且长度大再上链表。递归处理链表也有收获。链表天然是递归定义的结构一个链表 一个节点 一个更短的链表。所以链表的反转、合并、归并排序都可以用递归写得非常简洁。但要注意链表深度过大时递归会栈溢出生产环境里通常显式用迭代栈。最后再分享一个小技巧我写链表相关的代码时习惯在文件顶部列出所有操作的输入输出约定。比如“带头节点”“pos 从 0 开始”“删除返回 bool 并把值通过参数带出”。这不仅是给自己看的约定也是避免跨界合作时其他同事误用函数的保障。链表的代码写的是数据结构但真正考验的是你在边界条件下做决定的清晰程度。如果你能不看资料把带头结点单链表、不带头结点单链表、双向链表、循环链表的核心操作都写一遍还能说清每一步为什么这么写那你的数据结构基础就真的扎实了。