链表是数据结构面试与工程实践中的高频考点,但很多开发者对其指针操作仍停留在"看得懂、写不出"的阶段。本文从链表的内存结构出发,系统梳理遍历、增删节点等核心操作,并结合牛客 BM1–BM5 五道经典题目,带你真正吃透链表。

一、链表的内存本质:非连续存储与指针串联

链表与数组最大的差异在于物理存储的连续性。数组在内存中占据一块连续空间,可通过下标 O(1) 随机访问;而链表是一种物理上不连续、逻辑上有序的存储结构,元素之间的先后关系完全依赖节点内部的指针来维系。

以最常见的单向非循环链表为例,每个节点通常包含两部分:

  • 数据域:存放实际元素值;
  • 指针域:存放后继节点的地址(next)。

下面是单向链表节点的经典定义:

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};
img

理解这张图很关键:头指针(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 的反复练习,才能真正把"看得懂"转化为"写得对"。多写多画,指针自然就听话了。✅