链表是数据结构面试与工程实践中的高频考点,但很多开发者对其指针操作仍停留在"看得懂、写不出"的阶段。本文从链表的内存结构出发,系统梳理遍历、增删节点等核心操作,并结合牛客 BM1–BM5 五道经典题目,带你真正吃透链表。
一、链表的内存本质:非连续存储与指针串联
链表与数组最大的差异在于物理存储的连续性。数组在内存中占据一块连续空间,可通过下标 O(1) 随机访问;而链表是一种物理上不连续、逻辑上有序的存储结构,元素之间的先后关系完全依赖节点内部的指针来维系。
以最常见的单向非循环链表为例,每个节点通常包含两部分:
- 数据域:存放实际元素值;
- 指针域:存放后继节点的地址(next)。
下面是单向链表节点的经典定义:
struct ListNode {
int val;
ListNode* next;
ListNode(int x) : val(x), next(nullptr) {}
};

理解这张图很关键:头指针(head)本身不是节点,它只是指向第一个节点的"入口";尾节点的 next 为 NULL/nullptr,标志链表结束。这种结构决定了链表无法随机访问,任何定位都必须从头开始逐个跳转——这也是后续所有操作的时间复杂度根源。
二、基础操作全解析:遍历、申请、插入与删除
1. 遍历打印:访问链表元素只能顺着 next 指针逐跳前进,典型写法如下:
//遍历链表
void SListPrint(SListNode* phead)
{
SList* cur = phead; //这里我们创建一个指针来指向头结点的位置
while(cur)
{
print("%d->", cur->date); //打印当前节点的数据
cur = cur->next; //将指针指向下一个节点
}
}
2. 申请节点:链表节点通常是动态开辟的,大小等于结构体大小,开辟成功后写入数据、next 置空。C 语言版本如下(便于理解底层细节):
//申请节点
SListNode* SListBuyBode(SListDataType x)
{
SListNode* newnode = (SListNode*)malloc(sizeof(SlistNode)); //申请地址空间
if (newnode == NULL) //判断是否成功
{
perror("nalloc:");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
return newnode;
}
而在 C++ 中,使用 new 更为简洁且类型安全:
struct ListNode {
int val;
ListNode* next;
ListNode(int x) : val(x), next(nullptr) {}
};
ListNode* newNode = new ListNode(newValue);
实践建议:在 Go 中可直接用 &ListNode{Val: v} 创建节点,TypeScript/JavaScript 则用对象字面量 { val, next: null },Python 用 ListNode(val),各语言语法不同但思想一致。
3. 尾插:由于无法下标访问,必须区分两种情况——链表为空时直接插入;链表非空时遍历到尾部再挂接。
//尾插
void SListPushBack(SListNode** head, int x)
{
ListNode* newNode = new ListNode(x); //创建一个新节点
if(head == nullptr)
{
*head = newNode; //如果要插入的链表为为空,则直接将新建的节点作为头节点即可
}
else
{
ListNode* current = head;
while(current -> != nullptr)
{
current = current -> next;
}
current->next = newNode;
}
}
4. 头插:只需把新节点的 next 指向原头节点,再更新头指针,时间复杂度 O(1),是很多算法(如反转链表)的基石。
//头插
void SListPushFront(SListNode** head, int x) {
//申请新增节点
SListNode* newNode = new SListNode(x);
//将当前节点的next改为头节点
newNode->next = *head;
//将头节点设为当前节点
*head = newNode;
}
⚠️ 参数传递陷阱:当函数参数写作
SListNode* head时属于值传递,函数内部对
head的修改不会影响外部实参。若要修改外部头指针,应传入头指针的指针(
SListNode** head)或头指针的引用(
SListNode*& head)。这是初学者最容易踩的坑之一。
5. 删除节点:链表为空时不可删除;删除头节点需先保存原头,再把下一个节点更新为头;删除其余位置节点则需找到目标节点的前驱。完整实现如下:
//删除链表中值为 target的节点
ListNode* deleteNode(ListNode* head, int target)
{
//链表为空
if(head == nullptr)
{
return nullptr;
}
//删除头节点
if(head->data == target)
{
//先记下头节点位置
ListNode* temp = head;
head = head -> next;
delete temp;
return head;
}
//删除其余位置
ListNode* cur = head;
//找到目标位置的前一个节点
while(cur->next->data != target && cur->next != nullptr)
{
cur = cur - next;
}
if(cur->next != nullptr)
{
ListNode* temp = cur->next; //记录下要删除节点的下一个节点
cur->next = cur->next->next;//跳过要删除的节点
delete temp;//删除节点
}
return head;
}
代码末尾的 if(cur->next != nullptr) 判断尤为关键:如果链表中不存在值为目标值的节点,
target循环会一路执行到末尾,此时
while为
current->next,循环条件
nullptr中的
while使
current->next != nullptr && current->next->val != target循环终止。此时若贸然执行删除,就会误删或触发空指针异常。加上
current->next == nullptr判断,可有效防止在链表中没有目标节点时误删节点或引发空指针异常。
三、NULL 与 nullptr:C++ 空指针的类型安全之辨
在 C++ 中,
if (current->next != nullptr)和
nullptr都表示空指针,但差异不容忽视:
NULL:C++11 引入的关键字,类型为
nullptr,是专门表示空指针的特殊类型,可隐式转换为任意指针类型,类型更安全。例如:
int* ptr1 = nullptr;
double* ptr2 = nullptr;
nullptr:本质是宏,在 C 标准库头文件(如
std::nullptr_t)或 C++ 兼容头文件中定义。C 语言中通常定义为
NULL,C++ 中通常定义为
NULL或
<stdio.h>(长整型 0)。由于它本质是整数类型,赋值给指针时可能引发类型混淆。例如函数重载同时接受指针与整数参数时:
void func(int num);
void func(int* ptr);
func(NULL); // 在C++ 中,这可能会导致编译错误或调用错误的函数,因为NULL可能被解释为整数0
func(nullptr); // 明确调用func(int* ptr)
✅ 结论:现代 C++ 项目应统一使用 nullptr,避免重载解析歧义与隐式转换隐患。这一细节在跨语言迁移(如从 C++ 转 Go/TypeScript)时也值得留意——Go 用 nil、JS/TS 用 null 或 undefined,语义边界各不相同。
[AFFILIATE_SLOT_1]
四、牛客算法实战:BM1–BM5 逐题拆解
BM1 反转链表:核心思路是逐个翻转——用 pre 记录前序节点、cur 记录当前节点,每步先保存 cur.next,再让 cur.next 指向 pre,随后 pre 与 cur 同步后移,直至 cur 为空。
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) : val(x), next(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param head ListNode类
* @return ListNode类
*/
ListNode* ReverseList(ListNode* head) {
// write code here
ListNode* per = nullptr; //定义前序节点
while(head) //判断是否到结尾
{
ListNode* temp = head ->next; //记录下一个节点
head ->next = per; //反转当前节点
per = head; //前序节点向后移
head = temp; //当前节点后移
}
return per;
}
};
BM2 链表内指定区间反转:需要借助虚拟头节点(dummy)定位区间前驱,再对区间内部执行局部反转,最后重新拼接。初看较抽象,建议手绘指针变化图辅助理解。
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) : val(x), next(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param m int整型
* @param n int整型
* @return ListNode类
*/
ListNode* reverseBetween(ListNode* head, int m, int n) {
// write code here
//定义一个表头
ListNode* res = new ListNode(-1);
res -> next = head;
//定义前序节点
ListNode* per = res;
//定义当前节点
ListNode* cur = head;
//找到m位置
for(int i = 1; i < m; i++)
{
per = cur;
cur = cur->next;
}
//从m反转到n
for(int i = m; i < n; i++)
{
ListNode* temp = cur->next;//记录当前节点下一个节点
cur->next= temp->next;//越过当前节点
temp->next = per->next;//当前节点反转
per->next = temp;//前序节点连到最后
}
//返回去掉表头
return res->next;
}
};

BM3 每 k 个一组翻转:先遍历 k 步找到当前组尾(不足 k 个则直接返回本组 head),对当前小组执行翻转;记下翻转前的 head(翻转后变尾),将其 next 赋值为递归返回值(下一组头节点),递归入参为当前 tail。最后返回本组新头。
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) : val(x), next(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param k int整型
* @return ListNode类
*/
ListNode* reverseKGroup(ListNode* head, int k) {
// write code here
//找到每次反转的尾部
ListNode* tail = head;
//遍历k次找到当前组的尾部
for(int i = 0; i < k; i++)
{
if(tail == nullptr) return head;
tail = tail->next;
}
//定义所需的前序节点和当前节点
ListNode* per = nullptr;
ListNode* cur = head;
while(cur != tail)
{
ListNode* temp = cur->next;
cur->next = per;
per = cur;
cur = temp;
}
head->next=reverseKGroup(tail, k);
return per;
}
};
BM4 合并两个排序链表:典型的双指针归并,比较两链表当前节点值,小者接入结果链表并后移,最后拼接剩余部分即可。
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) : val(x), next(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param pHead1 ListNode类
* @param pHead2 ListNode类
* @return ListNode类
*/
ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
// write code here
ListNode* res = new ListNode(-1); //定义一个表头
ListNode* tail = res; //用来遍历的指针
while(pHead1 != nullptr && pHead2 != nullptr)
{
if(pHead1->val < pHead2->val)
{
tail->next = pHead1;
pHead1 = pHead1->next;
} else {
tail->next = pHead2;
pHead2 = pHead2->next;
}
tail = tail->next;
}
//处理剩余的
if(pHead1 != nullptr)
{
tail->next = pHead1;
}
else {
tail->next = pHead2;
}
return res->next;
}
};
BM5 合并 k 个已排序链表:采用分治 + 递归思想——将链表数组不断二分,直到只剩两个子数组,排序合并后再逐层回归。合并逻辑与 BM4 完全一致,难点在于递归拆分的边界控制。
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* ListNode(int x) : val(x), next(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param lists ListNode类vector
* @return ListNode类
*/
//用来合并两个链表
ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
// write code here
ListNode* res = new ListNode(-1); //定义一个表头
ListNode* tail = res; //用来遍历的指针
while(pHead1 != nullptr && pHead2 != nullptr)
{
if(pHead1->val < pHead2->val)
{
tail->next = pHead1;
pHead1 = pHead1->next;
} else {
tail->next = pHead2;
pHead2 = pHead2->next;
}
tail = tail->next;
}
if(pHead1 != nullptr)
{
tail->next = pHead1;
}
else {
tail->next = pHead2;
}
return res->next;
}
//划分合并区间
ListNode* divideMerge(vector &lists, int left, int right)
{
if(left > right) return NULL;
else if(left == right) //正好剩下最后一个链表
{
return lists[left];
}
//从中间分成两段
int mid = (left + right)/2;
return Merge(divideMerge(lists, left, mid), divideMerge(lists, mid + 1, right));
}
ListNode* mergeKLists(vector& lists) {
// write code here
//k个列表归并排序
return divideMerge(lists, 0, lists.size() - 1);
}
};
学习建议:这类题目"看懂"与"写对"之间隔着大量练习。建议每道题独立手写 2–3 遍,重点关注虚拟头节点、指针保存顺序、递归终止条件三个易错点。
[AFFILIATE_SLOT_2]
五、总结
链表的核心在于指针串联与无法随机访问这两大特性,由此衍生出遍历、头尾插、删除等基础操作的固定套路。掌握参数传递陷阱、nullptr 类型安全、虚拟头节点等细节,再配合 BM1–BM5 的反复练习,才能真正把"看得懂"转化为"写得对"。多写多画,指针自然就听话了。✅
浙公网安备 33010602011771号