苏黎世贝勒爷1. 链表练习从哪跌倒：先搞清楚链表治的是哪种"病"
链表这个数据结构，几乎所有学编程的人都绕不过去。但奇怪的是，翻开任何一本教材，链表的定义都很简单——"由一系列节点组成，每个节点包含数据和指向下一个节点的指针"，可一到自己动手写代码，不是空指针异常，就是链表断成两截，明明课本上画得清清楚楚的箭头，到代码里就变成了迷路的野指针。
我说句实在话：链表练不好，大多数时候不是代码写不对，而是脑子里根本没有建立起"节点+指针"的动态画面。数组是死的，链表是活的。
数组和顺序表（比如C++的vector、Python的list），本质上都是在内存里"紧挨着"排一列数据，像电影院的连排座位，一个萝卜一个坑。这有个好处：查找第k个元素按下标走就行，O(1)。坏处也很明显：如果要在中间插一个人，后排所有人都得挪窝；如果座位坐满了，还得重新找一大块整整齐齐的空地。
而单链表是另一套玩法——每个节点就像一个快递包裹，上面写着两样东西：货物本身（数据），以及"下一个包裹在我哪个小哥手上"（指针）。包裹不必摆在一起，甚至可以在全城各个角落。想插入一个包裹，只要让前一个包裹的小哥"改个接头暗号"指向新包裹，再把新包裹指向原本的下一个，完事。这里有个关键点：链表解决的不是"快"的问题，而是"灵活"和"省连续空间"的问题。
所以链表练习的价值，不在于"背会插入删除的几行代码"，而在于建立一种思维习惯：操作数据时，先想清楚"谁指向谁、谁还指着谁、改完会不会丢引用"。这个思维到了后面学树、图、哈希表、LRU缓存淘汰算法，全都要用。我就是因为当年链表练得扎实，后来看内核里那些复杂的数据结构操作，才没被绕晕。
另外，本次练习我按"单一职责"的思路设计：每次只练一个功能点，加上可运行的代码和验证方法。不是说题目简单，而是把复杂问题拆散，一个个击穿，再组合起来，比一上来就写一个几百行的"完整学生管理系统"效果好得多。下面我按自己带人练链表的路子，一步一步拆。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 动手敲代码前，让"节点"和"指针"在脑子里先成型
2.1 节点就是车厢和货物的关系
很多初学者在纸上画链表画得可溜了，一到定义结构体就发懵。我建议把这个过程想成搭火车：
- 车厢（节点）有两种身份：货物区（存数据）和连接区（存下一节车厢的位置）。
- 火车头（头指针）告诉你"列车从哪儿开始"。如果头指针指向空，说明这是一列空车。
- 最后一节车厢的连接区不指向任何东西，就是
nullptr（C++）或None（Python）。
一句话总结：一个节点是"我 + 下一个是谁"的组合体。这个画面一旦立住，后面所有操作都是在这句话上做文章。
拿C++来说，节点定义长这样：
cpp复制struct Node {
int data; // 货物
Node* next; // 连接区：指向下一个节点
Node(int val) : data(val), next(nullptr) {}
};
Python版本更直观，用类写：
python复制class Node:
def __init__(self, data):
self.data = data # 货物
self.next = None # 连接区，默认谁都不指向
注意C++里构造函数把next初始化成nullptr，这是好习惯。为什么？因为你new出来一个节点后，如果忘记初始化next，里面的值是随机的，后面遍历时就会把野地址当成下一个节点，直接崩溃。Python没有这个问题，因为None是默认对象。这是语言差异，但暴露的教训统一：指针不初始化，等于埋雷。
2.2 指针是"地址的便签"，不是数据本身
理解指针，我常用一个类比：指针不是快递，是"取件码"。它本身不保存数据，只告诉你数据在哪个格子。就像你手里拿着一张写着"3号柜-07箱"的便签纸，你去取货，这才是解引用（node->data）。
整个链表操作的精髓，说白了就是三件事：
- 拿便签（读取指针）
- 贴新便签（让指针指向新节点）
- 改便签（让一个节点的指针指向另一个节点）
每做一步操作，问自己一句：现在还有谁拿着旧的便签？如果没人拿了，那个节点是不是就找不到了？找不到节点，在C++里就是内存泄漏的根源，在逻辑上就是链表断链。
2.3 头节点：到底要不要？这是个好问题
练习链表时，很多人纠结一个问题：要不要设一个不存数据的"哨兵头节点"？
我的建议是：练习阶段，两种都试试，但先用不带哨兵的版本，因为它更接近操作的本质，能逼你把边界条件想清楚。后面做工程或面试题时，带哨兵节点往往能让代码简洁不少。
带哨兵的单链表长这样：
text复制head(哨兵，不存数据) -> 节点1 -> 节点2 -> nullptr
好处是什么？往链表头部插入节点时，不需要特殊处理"head是不是空"的问题，因为始终有一个固定的头。坏处是，遍历时要跳过哨兵，白白多走一步。
练习时我们从不带哨兵的版本开始，因为难度大一点，但练透了什么情况都不怕。
3. 核心操作逐个击破：建链、插链、删链、遍历链
3.1 创建链表：从空链表一路尾插
链表操作的基础是"从无到有"。一个空链表，就是头指针指向nullptr/None。接着依次插入数据，每次都在尾巴上挂新节点。
尾插的难点在于：你得先"走"到最后一个节点，才能挂节点。这就像火车接车厢，你得先走到最后一节，再把新车厢挂上去。
C++版本：
cpp复制#include <iostream>
#include <vector>
struct Node {
int data;
Node* next;
Node(int val) : data(val), next(nullptr) {}
};
// 尾插
void append(Node*& head, int val) {
Node* newNode = new Node(val); // 创建一个新节点
if (head == nullptr) { // 链表为空，新节点就是头
head = newNode;
return;
}
Node* cur = head;
while (cur->next != nullptr) { // 一直走到最后一个节点
cur = cur->next;
}
cur->next = newNode; // 把新节点挂到尾巴上
}
// 打印链表
void printList(Node* head) {
Node* cur = head;
while (cur != nullptr) {
std::cout << cur->data << " -> ";
cur = cur->next;
}
std::cout << "nullptr" << std::endl;
}
int main() {
Node* head = nullptr;
std::vector<int> nums = {3, 1, 4, 1, 5};
for (int num : nums) {
append(head, num);
}
printList(head);
return 0;
}
Python版本：
python复制class Node:
def __init__(self, data):
self.data = data
self.next = None
def append(head, val):
new_node = Node(val)
if head is None:
return new_node
cur = head
while cur.next is not None:
cur = cur.next
cur.next = new_node
return head
nums = [3, 1, 4, 1, 5]
head = None
for num in nums:
head = append(head, num)
cur = head
while cur is not None:
print(cur.data, end=" -> ")
cur = cur.next
print("None")
这里有个细节值得说：C++代码里我用的是Node*& head引用传参。很多新手写append(Node* head)发现函数执行完head还是空，就是因为传进去的是指针的副本，你在函数里改head只会改到副本上。**想让函数修改调用者手里的头指针，要么用引用，要么用二级指针，或者让函数返回新头指针。**Python里因为对象是引用传递，head的重新赋值必须通过return new_node收回来，否则也白搭。
3.2 插入操作：头插、按位置插，核心都是"先改新节点，再改前一个"
练习链表，插入是分水岭。写对插入，说明你对"谁指向谁"已经建立了肌肉记忆。
头插是最简单的操作，但也是最容易出错的一个。我来演示一下：
cpp复制void insertAtHead(Node*& head, int val) {
Node* newNode = new Node(val);
newNode->next = head; // 第一步：新节点指向旧头
head = newNode; // 第二步：头指针更新为新节点
}
这两步顺序能换吗？不能。如果先执行head = newNode;，那旧头的位置就丢了，newNode->next就不知道该指向谁，旧链表后半段直接"失联"。我在机试里见过无数次这种错误——思路完全对，就少画了一次箭头，整个链表只剩一个节点。
按位置插入就稍微复杂些。比如在第k个位置插入一个节点，先要考虑k的合法性。假设我们要在第1个位置（0-based）插入，也就是在"节点0和节点1之间"插入：
cpp复制void insertAt(Node*& head, int pos, int val) {
if (pos < 0) return;
if (pos == 0) { // 头插
insertAtHead(head, val);
return;
}
Node* newNode = new Node(val);
Node* cur = head;
// 先走到第 pos-1 个节点
for (int i = 0; cur != nullptr && i < pos - 1; i++) {
cur = cur->next;
}
if (cur == nullptr) {
std::cout << "插入位置非法" << std::endl;
return;
}
// 先接线：新节点指向后一个
newNode->next = cur->next;
// 再改线：前一个指向新节点
cur->next = newNode;
}
代码不长，但"先接后断"这个原则贯穿始终。新节点先指向后一个（先接线），再把前一个的指针改成新节点（后断线）。如果顺序反了——先把cur->next改成newNode，那"后一个"就丢了，新节点不知道自己该指向谁。
为了加深记忆，我可以告诉你我在教学时常用的口诀：插入两句话，新节点先认爹，再让爹认儿子；删除一句话，爹跳过儿子直接认孙子。
3.3 删除节点：先记住"下一代"，再跨过去
删除比插入容易些，但有一个陷阱：直接删就断了。必须先把"下一个节点的下一个节点"记下来，再改指针。
cpp复制void deleteNode(Node*& head, int val) {
if (head == nullptr) return;
// 如果要删的是头节点
if (head->data == val) {
Node* temp = head;
head = head->next; // 头指针指向第二个节点
delete temp; // 释放第一个节点的内存
return;
}
// 否则找到前一个节点
Node* cur = head;
while (cur->next != nullptr && cur->next->data != val) {
cur = cur->next;
}
if (cur->next == nullptr) return; // 没找到
Node* toDelete = cur->next;
cur->next = toDelete->next; // 跨过要删除的节点
delete toDelete; // 释放内存
}
注意两个细节。
第一，删除头节点要单独处理。因为删除操作需要"前一个节点"，但头节点没有前一个。如果你不想写这个特判，可以用哨兵节点或"二级指针间接修改"的写法，这里为了练习，先老老实实特判。
第二，C++里delete必须和new配对。删链表节点只改指针但忘记释放内存，短程序可能没事，长跑的程序就会内存泄漏。Python有垃圾回收，不用手动释放，但相同的问题变成了"对象没有引用时自动回收"的逻辑差异。
如果要在Python中实现删除，注意逻辑差不多，只是没有delete操作，让对象失去引用即可：
python复制def delete_node(head, val):
if head is None:
return head
if head.data == val:
return head.next # 头节点被跳过，失去引用后会被回收
cur = head
while cur.next is not None and cur.next.data != val:
cur = cur.next
if cur.next is None:
return head
cur.next = cur.next.next # 跳过目标节点
return head
3.4 遍历：一切操作的基础，也是最容易忽略的"练习"
遍历看起来最简单——从头走到尾，把每个节点的数据打印出来。但我强烈建议你单独练习遍历，因为很多问题的本质都是遍历的变体：
- 求链表长度 → 遍历计数
- 查找某个值是否存在 → 遍历判断
- 求中位数 → 快慢指针（本质是两个不同步调的遍历）
- 判断是否有环 → 快慢指针（同样是遍历）
遍历的模板代码就一个模式：
cpp复制Node* cur = head;
while (cur != nullptr) {
// do something with cur->data
cur = cur->next;
}
别忘了：while循环结束后，cur是空指针。如果你想在循环结束后再访问"最后一个节点"，就不能用cur，要么提前用一个last变量保存，要么循环条件改成while (cur->next != nullptr)。这就是练链表的细节敏感度。
4. 链表练习里最容易翻车的三个坑：空指针、断链、内存泄漏
4.1 空指针解引用
先看一个典型错误：
cpp复制Node* head = nullptr;
Node* cur = head->next; // 崩溃！head是nullptr，你还想访问它的next
这种错误通常在"链表为空"或"走到链表末尾"时爆发。比如上面的按位置插入，如果cur已经是nullptr你还访问cur->next，立刻崩。
我的经验是：每次访问一个指针的成员之前，先问一句：这个指针有没有可能为空？ 链表的窗口很小，就这几行代码，把每种情况下指针的值推演一遍，比debug半天划算。
常见的防御手法：
- 遍历时，循环条件里带上
cur != nullptr - 操作后继节点时，先判断
cur->next != nullptr - 不确定参数时，函数入口先判断
head == nullptr
这三条足够挡住90%的空指针问题。
4.2 断链：链表变成两截，后面全丢了
断链的错误通常发生在"插入"和"删除"时改变了指针顺序。
比如删除时先执行了delete toDelete;再执行cur->next = toDelete->next;，此时toDelete的内存已经被释放，你再访问它就是访问野指针，行为未定义。
再比如插入时先执行了cur->next = newNode;，再执行newNode->next = ...，可是新节点该指向"原本cur的下一个"，现在cur的下一个已经是新节点自己了——链表从中间断成两截，后半段找不到了。
判断链表有没有断，最直观的方法是打印。打印整个链表，看看是不是比预期的少了一截。但打印本身也有学问：如果链表成环（最后一个节点指向了一个不该指向的节点），打印会无限循环。所以打印时我一般加一个计数器，超过一定数量强行停止，防止程序卡死。
C++里我常用的调试打印是这样：
cpp复制void debugPrint(Node* head, int limit = 20) {
Node* cur = head;
for (int i = 0; cur != nullptr && i < limit; i++) {
std::cout << cur->data << " -> ";
cur = cur->next;
}
if (cur != nullptr) std::cout << "[疑似成环，已截断]" << std::endl;
else std::cout << "nullptr" << std::endl;
}
4.3 内存泄漏：只new不delete的隐形杀手
C++练链表，很多初学者只关注"逻辑对不对"，完全不关心内存释放。平时练习程序跑完就退出了，操作系统会回收内存，好像也没啥事。但一旦把链表搬到长期运行的服务、嵌入式设备、图形程序里，内存泄漏就是大事故——内存占用一点一点涨，最终程序崩溃。
所以练习链表的第二天，我就强迫自己写一个销毁函数：
cpp复制void destroyList(Node*& head) {
while (head != nullptr) {
Node* temp = head;
head = head->next;
delete temp;
}
}
这段代码的思路是：每次记录当前节点，头指针前进一步，然后释放当前节点。关键点在于"先保存下一个节点的地址再释放当前节点"——如果先释放当前节点，就再也找不到下一个了。
4.4 我的排查套路：从"画图"到"小样本测试"
遇到链表逻辑bug，我从来不死盯代码。我的方法是：
第一步，把链表画出来。脑子里或纸上，画出操作前后链表长什么样。比如删除节点3，操作前的链表和操作后的链表，各自是什么样子，中间差几条箭头。
第二步，把代码每一步对应到图上。cur = cur->next对应哪条箭头，newNode->next = cur->next对应哪条箭头，画出来就知道顺序对不对。
第三步，用"小样本测试"。不要一上来喂10万个数据，用3-5个节点测各种边界情况：空链表、只有1个节点、删除头节点、删除尾节点、插入到末尾、插入到中间。
这个方法看起来笨，但非常管用。我调试链表的效率靠的就是这套"先画图、再跑小样本"的流程，而不是瞎试。
5. 从练习1卷到进阶：逆序、环检测，以及链表思想的外溢
5.1 单链表逆序：把箭头全部掉头
单链表逆序是链表练习里经典中的经典。它考察的核心，还是"三个指针的配合"。
迭代法思路：准备三个指针——前一个（prev）、当前（cur）、下一个（next）。每次循环做四件事：
- 保存当前节点的下一个节点（
next = cur->next） - 把当前节点的指针指向前一个（
cur->next = prev） - 前一个指针移动到当前节点（
prev = cur） - 当前指针移动到下一个节点（
cur = next）
cpp复制Node* reverseList(Node* head) {
Node* prev = nullptr;
Node* cur = head;
while (cur != nullptr) {
Node* next = cur->next; // 不知道这道题会考，但平时练熟了就稳
cur->next = prev; // 箭头掉头
prev = cur; // 整体前移
cur = next;
}
return prev; // 新头是原链表的尾部
}
递归法也可以做逆序，代码很短但理解门槛高：
cpp复制Node* reverseListRecursive(Node* head) {
if (head == nullptr || head->next == nullptr) return head;
Node* newHead = reverseListRecursive(head->next);
head->next->next = head; // 让当前节点的下一个节点，反过来指向自己
head->next = nullptr; // 断开当前节点指向下一个节点的引用
return newHead;
}
递归法我画过好多遍才彻底理解。核心就一句话：递归返回时，链表后半段已经逆好了，新头是后半段最尾部的那个节点，然后把当前节点接到逆序后的末尾。
练习建议：迭代法必须滚瓜烂熟，递归法至少能配合画图手推一遍。面试时如果让你写链表逆序，迭代法是基本盘。
5.2 快慢指针：检测环和找中点的万能钥匙
除了逆序，链表进阶题目里的"快慢指针"思路也值得练到位。
比如检测链表有没有环：一个指针每次走一步，另一个指针每次走两步。如果链表成环，快指针早晚会"追上"慢指针；如果没环，快指针会先到nullptr。
cpp复制bool hasCycle(Node* head) {
Node* slow = head;
Node* fast = head;
while (fast != nullptr && fast->next != nullptr) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) return true;
}
return false;
}
这个题的价值在于：它考察的是"你知不知道遍历会遇到重复节点"——如果老老实实用哈希表记录访问过的节点，也能做，但空间复杂度是O(n)；快慢指针把空间复杂度降到O(1)，这是链表中"双指针减少开销"的典型代表。
找中间节点也可以用快慢指针：快指针走两步时慢指针走一步，当快指针到末尾，慢指针刚好在中间。
5.3 链表思想的外溢：从芯片设计到内核
练习链表，很多人以为它只是考试和面试的地基，离真实工程很远。其实链表的变体在现实世界无处不在。
热词里有一个"链表 芯片设计"，这在硬件设计领域确实存在——芯片内部的总线、寄存器管理、硬件描述语言实现队列和缓存时，会用链表式管理的思想来组织资源节点，只是这里的"指针"可能变成物理地址或索引，而不是C++里的内存地址。
更贴近日常的例子在操作系统里：文件系统的空闲块管理、网络协议栈的包缓冲队列、进程调度队列，全都有链表的影子。Linux内核里最基础的list_head结构，就是把链表做成"侵入式"的，把节点结构嵌进任意数据结构，然后通过宏操作访问兄弟节点——这套设计极其精巧，但底层思路还是"前一个记住后一个，后一个记住前一个"的循环双向链表。
所以练好链表，表面上是数据结构的基本功，实际上是在练一种"组织关系"的能力：多个元素在物理上不连续，但逻辑上要保持顺序，怎么在插入、删除、查找中维持这种关系，并且不让任何元素"失联"。这个能力，写业务代码用得上，写系统软件更用得上。
最后分享一个小技巧：练习链表的"跑步机式"训练法
我的体会是，链表这个东西，光看代码和原理不动手写，两天后必忘。我自己当年练习时用过一套"跑步机式"训练法，亲测有效。
找一天晚上，不看任何参考，手写以下内容，每项限时三分钟：
- 定义节点结构体（C++、Python各一遍）
- 实现尾插
- 实现头插
- 实现按位置插入
- 实现删除指定值的节点
- 实现链表逆序
- 实现打印链表
写完检查，画图验证。不熟的地方标记出来，第二天再来一轮。连续练三天，链表的肌肉记忆就建立了。之后再遇到什么"两数相加"、"合并有序链表"、"回文链表"之类的题目，基础操作不卡壳，解题思路自然就出来了。
练了一段时间之后还有一个意外的收获：以前看递归和指针总觉得隔了一层纱，把链表吃透之后，再回头理解树的前中后序遍历、图的邻接表，都是水到渠成的事。数据结构本质上是相通的，链表是你从"数组思维"切换到"引用思维"的第一扇门，这扇门推开了，后面就顺了。