408考研数据结构：双链表指针操作与插入删除全解析

如果你现在开始准备2027考研408，数据结构第一轮最容易让你怀疑人生的章节，往往不是树也不是图，而是线性表里的双链表。单链表背完还能磕磕绊绊写出来，一到双向，prior 和 next 两根指针来回一绕，头插尾插边界再一叠，代码基本就乱了。这篇文章我打算把双链表这件事彻底讲透，从内存结构到逐行手写实现，再到408真题里反复出现的考法和坑点，一次性写清楚。不管你是刚开始复习的小白，还是已经看完一遍教材但代码总出错的选手，按着这个思路捋一遍，双链表应该不会再成为丢分点。

1. 先搞清楚：双链表在408里到底占什么分量

1.1 数据结构45分，双链表是线性表章节绕不开的必选项

408的专业课一共150分，四门课里数据结构大约占45分。别看线性表只是其中一章，它在真题里的存在感非常强，而双链表又是线性表里最容易被单独拎出来考的实现细节。从近些年的试卷看，线性表的选择题经常围绕单链表、双链表、循环链表出，综合题里的算法设计大题也偏爱链表场景。可以说，链表相关题目是“选择会考、大题更会考”的常青树。

很多人复习的时候有个误区，觉得双链表不就是单链表多了个prior指针嘛，把单链表代码背熟就够用了。这个想法在考试里会很吃亏。因为双链表的每个指针操作都讲究顺序，改错一根指针就可能断链，选择题特别爱在这种“看似简单却容易绕晕”的地方设陷阱，大题也经常要求你在双链表基础上做逆置、拆分、去重之类的操作。你要是只会背单链表模板，考场上遇到双链表变体题，心态很容易崩。

1.2 双链表和单链表：不是多一根指针那么简单

单链表每个结点只存一个后继指针next，所以只能从头到尾单向走。双链表每个结点同时存前驱指针prior和后继指针next，这意味着你可以从两个方向遍历链表，也可以在已知某个结点的情况下，不借助头结点就直接把它的前驱找到。

这个差异带来三个直接后果。第一，删除某个已知结点时，单链表必须从头遍历找它的前驱，时间复杂度是O(n)；双链表直接通过prior指针就能拿到前驱，删除操作本身是O(1)。第二，双链表每个结点多花一个指针的存储空间，在408对空间复杂度的分析题里，这是一个需要写进答案的代价。第三，双链表的插入、删除操作涉及四根指针的修改，稍不注意就会丢链，这也是考试最喜欢考察的细节。

我辅导过不少学弟学妹，大家的共同感受是：单链表写完觉得“哦，原来如此”，双链表写完觉得“我是谁，我在哪，链表去哪了”。这种困惑非常正常，核心原因是你还没有在心里建立双链表的“指针连接图”，光背代码当然记不住。建议在纸上画一画结点之间的连接关系，画明白了再写代码，效率会高很多。

1.3 大纲里关于双链表的描述，其实藏着考点

408统考大纲在数据结构线性表部分，明确列出的考点包括线性表的定义、基本操作，以及线性表的存储结构。官方表述虽然不会直接写“双链表”三个字，但是“线性表的链式存储”天然包含单链表、双链表和循环链表，这是历年各版本教材都覆盖的标准内容。

换句话说，双链表不是冷门知识点，它是线性表链式存储家族里必须掌握的基础成员。更值得留意的是，408大纲反复强调“基本操作”，落到双链表身上就是初始化、判空、求长、查找、插入、删除、销毁这几个动作。真正常考的不是“双链表是什么”这种背诵题，而是“给一段插入或删除的指针操作代码，让你判断执行顺序是否正确”或者“让你在双链表上实现某个基于遍历的算法”。所以复习双链表时，不能光看概念，必须做到每个操作都能脱离课本手写出来。

2. 双链表的设计思路与结点结构剖析

2.1 结点为什么是 data + prior + next 三件套

双链表的基本结点在C语言里是这样定义的：

c复制typedef struct DNode {
    ElemType data;          // 数据域
    struct DNode *prior;    // 前驱指针，指向前一个结点
    struct DNode *next;     // 后继指针，指向后一个结点
} DNode, *DLinkList;

这里有个C语言初学者很容易忽略的细节：结构体内部不能直接用DNode *prior，因为在结构体定义完成之前，编译器还不知道DNode这个类型存在，所以必须写成struct DNode *prior。等整个typedef执行完，后面的DNode和DLinkList才能作为类型别名使用。

408的代码填空题和手写算法题，通常默认使用类似的结点定义。有些同学喜欢自己发明风格，比如指针名用a、b、c这种简写，平时练习无所谓，但考场上阅卷是按步骤给分的，清晰的命名能帮阅卷老师快速看懂你的思路，也方便你检查自己的代码逻辑。建议养成p、q、r、s这类链表操作的通用命名习惯，p一般是工作指针或目标结点，s、q经常是待插入或待删除的结点，这样和教材答案保持一致，复习和考试都顺手。

2.2 带头结点还是带头指针？为什么默认带头结点

链表有两种常见的组织方式：带头结点和不带头结点。二者的区别在于，带头结点的链表会额外创建一个头结点，它的data域通常不存有效数据，只是作为链表的“哨兵”存在；而头指针L指向这个头结点。不带头的链表里，头指针L直接指向第一个真正存储数据的结点。

408的链表题目和大部分教材（尤其是王道、天勤这类考研辅导书）默认使用带头结点的写法。原因很现实：带头结点可以把“在表头插入”和“在表中间插入”统一成同一种逻辑，不需要为“插入后链表会不会变成空表”单独写分支；同时空表的判断条件也特别统一，都是L->next == NULL。这样写出来的代码更简洁，边界情况更好处理。

你在自己写题的时候，第一件事就应该确认题目说的是带头结点还是不带头结点。如果是手写算法题，题干没明说，我建议你也带头结点，因为大部分参考答案就是带头结点版本，判卷更容易对应上。不过平时练习时，最好把不带头结点的版本也思考一遍，因为有些选择题会给不带头结点的代码，你得能看懂。

2.3 指针操作的本质：先接后断，别丢链表

双链表所有复杂操作的背后，其实只有一条核心原则：先接上新连接，再断开旧连接。这条原则用大白话讲就是，你动手改链表指针之前，必须保证链表的每一部分都能从某个入口遍历到，绝对不能出现某段结点突然没有任何指针指向它的情况，否则那段结点就“丢”了，再也找不回来，这就叫断链。

插入操作尤其要小心。比如在p结点之后插入s结点，新手最常见的错误是先执行p->next = s，再执行s->next = p->next。问题是p->next已经被改成了s，第二个语句实际上让s的next指向了自己，原来p后面的整段链表就彻底找不到了，这是灾难性的bug。

正确顺序是先把s和p的原始后继结点“接上”，再回过头来修改p的指针。记住这个原则之后，你再去看双链表的插入代码，会发现它不再是死记硬背的四个语句，而是一个有逻辑的顺序问题。后面第三节我会把这种顺序感落实到每一段代码里。

3. 手把手实现双链表核心操作

3.1 初始化与判空：一切操作的地基

双链表最标准的带头结点初始化写法如下：

c复制bool InitDLinkList(DLinkList *L) {
    (*L) = (DNode *)malloc(sizeof(DNode));
    if (*L == NULL) {
        return false;       // 内存分配失败
    }
    (*L)->prior = NULL;
    (*L)->next = NULL;
    return true;
}

有几个必须提的点。第一，头结点的prior和next都要置空，很多人只记得next置空，prior忘记，后面一旦做逆序遍历或者某些边界判断，野指针就直接崩了。第二，malloc之后一定要判断返回值，408代码题虽然不会真的运行，但阅卷时会看你对内存分配失败的异常处理，写上if (*L == NULL) return false;是加分项，也是好习惯。第三，DLinkList *L这种二级指针写法是为了在函数内部修改头指针本身的值，408中如果写InitDLinkList(DLinkList &L)这种C++引用风格，在纯C题目里是不合法的，建议用二级指针的写法。

判空操作就非常简单了：

c复制bool Empty(DLinkList L) {
    return L->next == NULL;
}

带头结点双链表的空表特征就是L->next == NULL，因为没有任何第一个数据结点。

3.2 尾插法建表与正向遍历：先把骨架立起来

初始化完成之后，我们需要一种方法把数据结点一个个串起来。尾插法的思路是维护一个尾指针r，每次把新结点接到r的后面，然后移动r。完整代码如下：

c复制void CreateListTail(DLinkList *L, ElemType arr[], int n) {
    InitDLinkList(L);
    DNode *r = *L;   // r始终指向链表的最后一个结点
    for (int i = 0; i < n; i++) {
        DNode *s = (DNode *)malloc(sizeof(DNode));
        if (s == NULL) return;
        s->data = arr[i];

        // 关键四步：把s接到r后面
        s->prior = r;
        s->next = NULL;
        r->next = s;
        r = s;
    }
}

这段代码里，新结点s刚分配出来时，它自己的prior要指向前一个结点r，next置空表示它是新表尾。然后让旧表尾r的next指向s，最后更新r，让r指向新的表尾。

这里我再强调一下遍历的代码，因为后面几乎所有算法题都要用到：

c复制void PrintList(DLinkList L) {
    DNode *p = L->next;   // 跳过带头结点
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

遍历双链表时，工作指针p从第一个数据结点开始，一直走到NULL为止。单链表只能这么正向走，但双链表还能从尾部往前逆序遍历，这也是它的核心优势。

3.3 按位查找与后插操作：大题里最常用的工具函数

按位查找的逻辑在链表题里几乎处处用得到。比如第i个位置插入、删除，第一步都是找到第i-1个结点，也就是目标位置的前驱。

c复制DNode *GetElem(DLinkList L, int i) {
    if (i < 0) return NULL;
    DNode *p = L;
    int j = 0;
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

这个函数返回第i个结点。注意i=0时返回的是头结点，因为初始时p指向头结点L并且j=0，循环一次都不执行，直接返回L，这个设计在插入操作里特别好用。

双链表的核心插入操作，是在已知结点p之后插入新结点s，也就是“后插”。它是所有双链表插入的基础，因为不管是头插法、尾插法还是在第i个位置插入，本质上都可以转化为“在某个已知结点后面插入”。代码如下：

c复制bool InsertNextDNode(DNode *p, DNode *s) {
    if (p == NULL || s == NULL) {
        return false;
    }
    // 第一步：s先和后继结点建立联系
    s->next = p->next;
    // 第二步：如果p后面有结点，让那个结点的prior指回s
    if (p->next != NULL) {
        p->next->prior = s;
    }
    // 第三步：s指向前驱p
    s->prior = p;
    // 第四步：p的next指向s
    p->next = s;
    return true;
}

不少同学背这段代码的时候，会把第二步漏掉，或者漏掉if (p->next != NULL)这个判断。这里我要详详细细解析一遍：如果p原本就是表尾，p->next是NULL，那NULL->prior这个操作就是空指针访问，程序直接崩。所以第二步必须有这个if判断。这个细节在选择题里经常出现，出题人故意把if去掉或者调换语句顺序，让你判断代码是否有问题。你只要记住“p后面是NULL时不能动prior”这条铁律，这类题目就难不倒你。

有些教材还会把前插操作单独列出来，即“在p结点之前插入s”。实际上双链表的前插可以通过后插变过来：先获取p的前驱，再在前驱后面做后插。等价写法是s->prior = p->prior; s->next = p; p->prior->next = s; p->prior = s;，但考场上一旦动过多指针，出错率会提高，所以我更推荐统一转化为后插，思路更清晰。

3.4 删除操作的两个变体与内存释放

删除双链表中的某个已知结点q，最直接的做法是利用q->prior和q->next两个指针，把q从链中摘下来：

c复制bool DeleteDNode(DNode *q) {
    if (q == NULL || q->prior == NULL) return false;
    DNode *prev = q->prior;
    prev->next = q->next;
    if (q->next != NULL) {
        q->next->prior = prev;
    }
    free(q);
    return true;
}

这个实现里，我先用一个临时变量prev保存q的前驱，然后再改prev->next。为什么要先保存？因为一旦执行q->prior->next = q->next，q->prior本身并没有变，其实直接连写也行，但用临时变量可以让逻辑更清楚，后续调试也方便。if (q->next != NULL)仍然不能丢：当q是表尾结点时，q->next为NULL，空指针没有prior可修改。

另一个更常见的场景是“删除p结点的后继”。这个操作通常写成：

c复制bool DeleteNextDNode(DNode *p) {
    if (p == NULL || p->next == NULL) {
        return false;   // p不存在，或p已经是表尾，没有后继可删
    }
    DNode *q = p->next;   // q是要删除的结点
    p->next = q->next;
    if (q->next != NULL) {
        q->next->prior = p;
    }
    free(q);
    return true;
}

这一步先判断p->next是否存在，如果p后面没结点却还去删，free一个NULL指针会直接报错。删除操作最容易被忽视的是内存释放，在408手写代码题里，凡是涉及删除，你都要记得写free(q)，这代表你真正理解了“删除结点”和“让结点脱离链表”是两回事：断开连接只是把它从逻辑链路上摘下来，free才是在内存中真正回收它。

3.5 销毁整表与逆序遍历：收尾动作别马虎

销毁一个带头结点的双链表，最稳妥的思路是反复删除第一个数据结点，直到链表只剩头结点，最后释放头结点：

c复制void DestroyList(DLinkList *L) {
    while ((*L)->next != NULL) {
        DeleteNextDNode(*L);   // 每次都删除第一个数据结点
    }
    free(*L);
    *L = NULL;
}

这里用DeleteNextDNode头结点作为参数，每次删除链表的第一个数据结点。循环结束后，头结点->next已经是NULL，链表里没有任何数据结点了，再free头结点。这个写法比“用一个p指针从头走到尾逐个free”更不容易出错，因为它复用了已经写好的、经过验证的删除函数。

逆序遍历是双链表专有的操作，利用prior指针从表尾向前走。写逆序打印之前需要先找到表尾，这需要一趟O(n)的查找：

c复制void PrintListReverse(DLinkList L) {
    DNode *p = L;
    while (p->next != NULL) {
        p = p->next;      // 先走到最后一个结点
    }
    while (p != L) {      // 只要还没走到头结点就继续
        printf("%d ", p->data);
        p = p->prior;
    }
    printf("\n");
}

第二个循环停止条件是p != L，也就是停在头结点就结束。你也可以简写成while (p->prior != NULL)，两者效果一样。逆序遍历在双链表相关的算法设计题里是很常用的辅助思路，比如判断回文结构、从后往前查找第k个元素等，都可能用到。

3.6 循环双链表：判空和遍历条件全部变化

循环双链表是双链表的重要变体：表尾结点的next不再指向NULL，而是指向头结点；头结点的prior也不再是NULL，而是指向表尾结点。代码上唯一的区别是初始化和边界判断变了：

c复制// 初始化循环双链表
(*L)->prior = (*L);
(*L)->next = (*L);

这么设计之后，“判断是否为空”从L->next == NULL变成了L->next == L；正向遍历的停止条件从p != NULL变成了p != L；在p之后插入s时，第二步if (p->next != NULL)的判断就不需要了，因为循环链表中p->next永远不为空。对于算法设计，循环双链表的“从任一结点出发都能遍历整个链表”这个性质经常被用来简化问题，例如约瑟夫环、双向循环队列等。选择题如果出现循环双链表的空表判断条件，答案一定是L->next == L，这一点要记得很牢。

4. 从408真题角度反推双链表的常见考法

4.1 选择题：重点考指针顺序和边界情况

408选择题如果涉及链表，常见的考法有这么几类。

第一类是“给出插入/删除代码的空缺处，选择正确语句”。典型例子是：已知p指向双链表中的某个非表尾结点，要删除p本身，问你代码p->prior->next = p->next; ____; free(p);横线处应该填什么。正确答案是p->next->prior = p->prior，但出题人会混入p->next->prior = p、p->prior->next = p这类错误选项。遇到这种题，我的方法是在草稿纸上画出三个结点（前驱prev、当前p、后继next），每执行一个语句就划掉旧指针、画上新指针，多选题也照样能推出来。

第二类是“判断算法的时间复杂度”。比如问“在双链表中查找第i个结点的前驱的时间复杂度是多少”，答案通常是O(n)，因为即使有prior指针，如果不知道具体位置，还是要从头遍历。但如果是“已知结点p的地址，删除p的时间复杂度”，答案就是O(1)。这种题考的是你能否分清“已经知道哪个结点”和“还要先找到这个结点”这两种情况，千万别把二者混为一谈。

第三类是“空表判断和边界条件”，上面讲的循环双链表判空就是一个典型。还有一类容易错的题，考核在表尾删除或者插入时是否需要特殊处理，很多错误选项就是漏掉对尾结点next为空的判断。

我不建议你刷完题就完事，而是把做错的链表选择题都归到一个错题本里，在题目旁边标注它到底考的是“指针顺序”还是“边界判断”还是“复杂度分析”。归几次之后你就会发现，408链表选择题翻来覆去就这几个套路，识破了就不慌。

4.2 算法大题：双链表往往是“载体”而不是主角

历年408算法设计大题里，双链表作为题目背景出现过多次，但仔细分析会发现，出题人并不是为了考“双链表本身的插入删除”，而是把双链表当作一个既能正向遍历又能逆向访问的数据载体，在此基础上考察你设计算法的能力。

最常见的三个套路是：

一是逆置问题。比如要求“设计一个算法，将带头结点的双链表就地逆置”。思路仍然是头插法：依次摘下原链表中的每个结点，用头插法重新插回头结点后面。因为双链表每个结点都有prior和next，逆置之后要把两者都正确更新，比单链表逆置多一个步骤，稍不小心就会把prior指错方向。二是在双链表中删除满足某条件的结点，比如删除所有值为x的结点，遍历一遍，挨个删除并free，考察的还是DeleteNextDNode的基本功。三是双链表的排序问题，比如按元素值递增排列，虽然算法本身是插入排序的思路，但在双链表上实现时，你要用prior和next两个方向寻找插入位置，这正是双链表的优势所在。

我特别想提醒的是，算法大题的核心还是“数据结构+算法”的综合设计，链表只是容器。很多同学看答案觉得自己都会，一到12月模拟考就发现写不到一半就卡住了，原因是平时只看不练。408的手写代码和大题必须自己在纸上完整写出来，写错了再对照答案修正，这样才能把“看懂”转化成“会写”。

4.3 手写代码的阅卷逻辑与答题规范

我在前面反复提到“阅卷按步骤给分”，这是408手写代码题一个非常现实的问题。从历年考生反馈来看，算法设计大题通常不会要求代码100%可编译，而是看你的逻辑框架、关键步骤和边界处理是否到位。所以答题时建议先写思路、再写代码。草稿阶段就把“先找到第i-1个结点”“判断p->next是否为空”这些关键步骤写清楚，阅卷老师能快速判断你理解了问题，即使代码有些小语法瑕疵也能拿到大部分分数。

代码本身也有几个约定俗成的加分细节：malloc之后判空、插入删除前做合法性判断、删除结点后记得free、函数名和变量名见名知意。这些细节在平时练习时可能觉得繁琐，但它们在阅卷时就是区分“背模板”和“真会写”的试金石。另外一个容易被忽略的问题是空间复杂度，如果题目要求“尽量高效”或“在O(1)空间内解决”，你的算法就不能开额外数组，必须用链表自身的指针操作完成，这往往就是选择头插法而不是开辟新链表的根本原因。

5. 自己写双链表代码时的高频问题排查

5.1 常见错误与崩溃原因速查表

我自己在带复习的过程中，收集了双链表代码报错频率最高的几个原因，整理成一张速查表，大家可以对照自查。

如果你在自己电脑上跑代码，我强烈建议装一个带调试功能的IDE（Visual Studio或者CLion都可以）。在插入和删除操作前后打断点，查看链表每个结点的prior和next值，一旦发现某个指针值不对，就是那一步出了问题。链表调试很难靠“读代码”一眼看出错，用监视窗口看指针指向的内存，效率至少翻一倍。

5.2 一个真实排查案例：插入后头结点失踪

我带过一个学弟，他的代码逻辑看起来完全没问题，初始化、建表都过了，但一旦执行带条件的按位插入，程序就崩溃。最后一行一行排查，发现问题出在GetElem上。他写的查找代码是从L->next开始的，i=0的时候直接返回了第一个数据结点，而不是头结点。当插入位置是1，也就是要插在头结点之后时，GetElem返回了第一个数据结点，结果插入变成了插在第一个数据结点之后，位置错了不说，边界判断也跟着崩。

这个案例特别典型，因为它暴露了一个常见认知偏差：很多同学默认查找函数返回的是“数据结点”，却忘了带头结点的链表中，位置0对应的是头结点。408算法题里，如果你把“第1个位置”理解成“第一个数据结点”，那插入删除的目标前驱就会整体偏移一位，连锁出错。避免的方法是写代码时明确注释：GetElem(L, 0)返回头结点，GetElem(L, 1)返回第一个数据结点。

5.3 双链表复习和自测的实用建议

第一轮复习双链表的时候，不要急着刷综合题。我建议按下面的顺序做三轮自测：

第一轮，关书默写核心六个函数：初始化、尾插建表、按位查找、后插、删除、销毁。每写一个函数都在旁边画对应的链表指针变化图，写错了就回去看，直到一次通过。

第二轮，自己给自己出变体题。每掌握一个标准操作，就改一个条件重新实现。比如“把后插改成前插”“把删除p的后继改成删除p本身”“把带头结点改成不带头结点”“把普通双链表改成循环双链表”。四个变体都写过以后，你对双链表的理解就不再是死记硬背，而是真正建立了指针操作的直觉。

第三轮，拿408真题的链表大题做限定时间训练。一般算法大题建议控制在15到20分钟内，先写思路再写代码。写完后对照标准答案，不只看代码对不对，更要看你的边界判断是否齐全、复杂度分析是否写清楚。坚持三轮之后，双链表相关的题目基本不会再成为你的卡点。

最后再聊几句备考心态

我自己复习408的时候，线性表是被我翻来覆去折腾最久的部分。原因很简单，后面的栈、队列、串、树、图，很多实现都依赖链表的基本功，这里欠下的债，后面迟早要加倍还。双链表作为链式存储里操作最繁琐、最容易出错的一种结构，值得你在前期多花时间把它磨透。现在多画一张指针图，多写一遍删除代码，11月上考场的时候就少一分慌张。大家如果后面遇到双链表相关的具体问题，欢迎在评论区把代码贴出来一起讨论，我看到了都会尽量回复。