双链表和求和，乍一看是C语言课程里最不起眼的组合。链表嘛，无非是遍历、累加、输出。可就是这么一个“简单”的功能，我在带新人和看课程设计代码时，见过太多翻车案例：有人把链表构建成了死循环，有人用前驱指针倒退时直接崩溃，还有人对着头结点反复求和漏掉了数据结点。这篇东西，我不打算只给一段能跑的代码，而是把“双链表求和”背后牵扯出的结构设计、构建方式、遍历边界和调式思路完整梳理一遍，适合刚学完指针和结构体、准备动手写数据结构的初学者，也适合正在做课程设计、想把自己的链表代码写得更扎实的同学参考。

1. 从零搭双链表：为什么结构体里必须要写三个成员

有人说双链表不就是在单链表的结构体里多塞一个指针吗？这话对了一半。多出的那个指针，换来的不仅是“能往回走”这个花哨能力，而是让很多操作的时间复杂度从 O(n) 降到了 O(1)。但在讨论删除、插入之前，得先把结点的地基打对。

1.1 结点类型定义：数据域、前驱指针、后继指针的职责划分

定义双链表结点，教科书上通常长这样：

typedef struct Node { int data; // 数据域，这里放的是要求和的数值 struct Node *prev; // 前驱指针，指向前一个结点 struct Node *next; // 后继指针，指向下一个结点 } Node;

这段代码里有三个容易被忽略的细节。第一个，struct Node *prev这个成员的类型是struct Node *，不是Node *。因为在typedef生效之前，编译器还不知道Node是个什么东西，所以结构体内部只能用完整的struct Node来声明指针。第二个，数据域的类型，我用了int。如果你要处理的是浮点数求和，把int换成double就行，但要留意求和结果的数据类型也得跟着变，不然小数部分会被直接吞掉。第三个，prev和next语义上的分工：next负责正向遍历，prev负责反向遍历。两者配合，才让“已知某个结点、同时拿到它两边的邻居”成为可能。

很多初学者会问：我求和只用得到next，那prev是不是可以不要？从“完成题目”的角度看，确实可以不要；但从“学好双链表”的角度看，这个想法很危险。因为求和只是载体，老师布置题目的真实意图往往是让你把双链表的增、删、遍历全部跑通。你一旦把prev省掉，后面写反向求和、双向冒泡、双向插入时就要全部推翻重来。代码里多一个指针，付出的代价只是每个结点多 8 个字节（64 位系统下指针大小），换来的是整个数据结构能力的翻倍。

1.2 初始化链表的正确姿势：头结点与二级指针的选择

定义完结点，接下来就是初始化。这里有一个绕不开的选择：到底用一级指针还是二级指针？

// 方式一：一级指针，返回新头结点 Node *create_list() { Node *head = (Node *)malloc(sizeof(Node)); head->next = NULL; head->prev = NULL; return head; } // 方式二：二级指针，在函数内部修改指针 void init_list(Node **head) { *head = (Node *)malloc(sizeof(Node)); (*head)->next = NULL; (*head)->prev = NULL; }

我个人的建议是优先用方式一，也就是返回新头结点的写法。原因不复杂：二级指针虽然在“修改指针本身”的场景里非常标准，但初学者特别容易在(*head)和*head之间把括号写丢，导致编译阶段各种语义错误。返回值的写法意图更直白，而且调用端写成Node *head = create_list();就够了。

再啰嗦一句头结点。我见过不少同学把头结点直接当成第一个数据结点来用，也就是把第一个求和数值存在head->data里。这种做法不是不行，但会让所有算法的边界判断变得很痛苦：插入时你得判断当前结点是不是头结点，删除时又得区分“删的是头结点”和“删的是普通结点”。比较省心的做法是设立一个不存储有效数据的头结点，让head->next指向真正的第一个数据结点，head->prev永远为 NULL。这样遍历和求和时，从head->next出发，一切边界都变得对称。

2. 把数据装进链表：头插法与尾插法对求和顺序的影响

结构体和初始化函数就绪后，下一个问题就是：数据怎么进来？常见的两种方式——头插法和尾插法——不仅代码写法不同，连最终链表里的数据顺序都是反的。

2.1 头插法与尾插法的行为差异对比

先说结论，再看代码。给定一串数据 1、5、3、9、2：

• 尾插法依次把每个新结点挂到链表尾部，最后链表顺序是 1 → 5 → 3 → 9 → 2，和输入顺序完全一致。
• 头插法每次把新结点插入到头结点的正后方，也就是成为新的第一个数据结点，最后链表顺序是 2 → 9 → 3 → 5 → 1，恰好反转。

对“求和”这个操作本身来说，因为加法满足交换律，两种方式算出来的总和完全一样。所以如果题目只要求输出一个总和，用哪种方式构建都无所谓。但一旦题目扩展为“求前 k 个结点之和”或者“找出链表中第一个大于某个值的结点”，顺序就立刻变成决定性因素了。建议在做题之前先确认输入数据的顺序是否会影响输出，这是读题时就要想清楚的，代码反而是后面的事。

2.2 两种插入的完整代码与指针交换细节

尾插法的实现，需要额外维护一个tail指针来记录链表末尾，避免每次插入都从头遍历到尾：

void insert_tail(Node *head, int val) { Node *new_node = (Node *)malloc(sizeof(Node)); new_node->data = val; new_node->next = NULL; Node *cur = head; while (cur->next != NULL) { cur = cur->next; } // cur 此时是最后一个结点 cur->next = new_node; new_node->prev = cur; }

这里有个很容易写错的细节：很多人的草稿里只写了cur->next = new_node;，忘了给new_node->prev赋值。单链表时代无所谓，但双链表的prev必须在结点诞生那一刻就明确指向它的前驱。否则后面用prev反向遍历求和时，这个新结点就是断开的。如果你用tail指针优化，插入逻辑会变成tail->next = new_node; new_node->prev = tail; tail = new_node;，连 while 循环都省掉，这也是工程里最常见的写法。

头插法的指针交换更多，也是最容易写乱的地方：

void insert_head(Node *head, int val) { Node *new_node = (Node *)malloc(sizeof(Node)); new_node->data = val; if (head->next == NULL) { // 链表为空，前驱和后继都直接指向 NULL new_node->next = NULL; new_node->prev = head; head->next = new_node; } else { new_node->next = head->next; head->next->prev = new_node; new_node->prev = head; head->next = new_node; } }

判断空链表和非空链表要分别处理，这一点不是可有可无的。在空链表里，head->next是 NULL，如果你直接执行head->next->prev = new_node;，就是对空指针解引用，程序当场段错误。写双链表插入的统一心法是：先把新结点的两条链接接好，再改老结点的两条链接，最后把头结点或尾结点的指针指向新结点。顺序错了，链表就会断。

3. 求和函数设计：一次遍历里藏着的边界条件

链表搞定了，求和本身反而是最简单的一环。一个循环、一个累加变量，几行代码的事。但简单的代码，其实是检验你有没有把链表边界彻底混明白的试金石。

3.1 正向求和与反向求和的完整实现

正向遍历求和，用next指针一路走到 NULL 为止：

int sum_forward(Node *head) { int total = 0; Node *cur = head->next; // 跳过不存数据的头结点 while (cur != NULL) { total += cur->data; cur = cur->next; } return total; }

反向遍历求和，则是双链表相对单链表独有的能力，从链表尾部往前走：

int sum_backward(Node *head) { int total = 0; Node *cur = head; // 先找到最后一个结点 while (cur->next != NULL) { cur = cur->next; } // 再从尾部向头部累加 while (cur != head) { // 停到头结点为止，因为头结点不存数据 total += cur->data; cur = cur->prev; } return total; }

注意反向求和里while (cur != head)这个终止条件。头结点是一个不存数据哨兵，cur回到head就说明所有合法结点都遍历完了。如果把终止条件写成while (cur != NULL)，会遇到同样能跑通但逻辑上更别扭的情况，因为走到head之后还会再走一步，等于对头结点的prev（即 NULL）做了一次无意义取值。代码能跑和代码写得精准是两码事，我建议从一开始就养成用“哨兵结点”做边界判断的习惯。

3.2 空链表保护与循环链表的特殊处理

如果一个链表只有头结点，也就是head->next == NULL，正向求和时while循环一次都不执行，返回 0，逻辑本身就正确，不需要额外写保护。但这个“返回 0”真的合理吗？回到需求本身去想：如果题目没有明确空链表时应该返回什么，你可以选择返回 0，也可以在函数外先判断链表是否为空，再决定是否调用求和函数。在真实项目里，我更倾向让求和函数自己保持简单——只负责遍历累加，空链表返回 0 是自然的数学语义（空集合求和约定为 0），调用方自己去判断数据是否合法。

还有一类题会要求用双向循环链表，也就是最后一个结点的next指向头结点，头结点的prev指向最后一个结点。这时候正向遍历的终止条件就要从cur != NULL改成cur != head，否则你会在循环链表里无限绕圈。解决循环链表求和死循环有一个经验法则：先在纸上把人走过的路径画出来，确认“什么时候回到起点”，再用这个条件去写循环。不要一上来就敲代码，链表题几乎所有的坑都能靠画图提前排掉。

4. 求和踩坑实录：一晚上排掉的两个雷

题目简单，不代表坑就少。我自己调试过一份学生的双链表求和代码，两个看似不相关的故障，根因都指向同一个领域：指针管理不严。这段排查过程我完整写出来，比直接丢一段“正确代码”更有参考价值。

4.1 雷区一：初始化不完整导致遍历越界

第一个现象是程序一启动就崩溃，终端报Segmentation fault。在编辑器里加上printf定位后，发现崩在sum_forward的total += cur->data这一行。单独看求和函数，逻辑没有问题，问题只可能出在传入的链表上。

用调试器检查head->next的值，发现它指向一个非 NULL 的野地址。再回溯创建链表的代码，真相是：分配头结点后没有把next和prev初始化为 NULL，直接用这个“脏头结点”去尾插。尾插函数里while (cur->next != NULL)一判断，发现cur->next是乱七八糟的值，和 NULL 比较结果不成立，于是把新结点挂到了错误的位置。

这类问题的排查要点是：不要盯着崩溃点猛看，而是向上追踪数据的来源。段错误只是结果，链路在初始化阶段就已经坏了。修复方法也简单，create_list里head->next = NULL; head->prev = NULL;这两行缺一不可。

4.2 雷区二：反向求和时 prev 指针失效

第二个现象更隐蔽。正向求和结果正确，一调用反向求和就输出一个极大的数或者直接卡死。这种情况，十有八九是构建链表时某个结点的prev没有正确指向它的前驱。

具体到我排查的那份代码，问题出在头插法的空链表分支。代码里只写了head->next = new_node;，却没有写new_node->prev = head;。于是第一个结点成了“孤儿结点”，它的prev指向未初始化的垃圾值。反向遍历走到这个结点时，cur = cur->prev直接跳到未知内存，后面的行为完全不可预测。

修复后我还做了一次完整的双向验证：正向打印一遍数据，再反向打印一遍数据，两个方向输出顺序应当正好相反。这个方法强烈推荐，它是检验双链表链接是否完整的最高效手段之一。很多同学只验证了正向，导致prev链路坏了自己完全不知道，直到某道题需要反向遍历时才突然爆雷。

5. 从“求和”到“遍历框架”：这道题的真正进阶方向

一个只会写sum_forward的代码，和能从求和里提炼出通用遍历框架的代码，在面试官眼里是两个完全不同层次的东西。因为求和太特殊，它不需要关心当前结点的位置，也不需要中途停下游荡，本质上是“对每个元素执行一次确定性操作”。这个模式，值得抽象出来。

5.1 用函数指针把“累加”升级成通用遍历回调

C 语言里的一种经典做法是把遍历和具体操作解耦，重叠的逻辑（遍历链表）写一次，变化的逻辑（对每个结点做什么）交给函数指针：

typedef int (*visit_fn)(int data, void *ctx); int list_traverse(Node *head, visit_fn fn, void *ctx) { int count = 0; Node *cur = head->next; while (cur != NULL) { fn(cur->data, ctx); cur = cur->next; count++; } return count; }

一个求和的回调可以是这样的：

typedef struct { int sum; } sum_ctx; int add_to_sum(int data, void *ctx) { ((sum_ctx *)ctx)->sum += data; return 0; }

调用时，两行代码得到结果：

sum_ctx s = {0}; list_traverse(head, add_to_sum, &s); printf("%d\n", s.sum);

顺着这个思路，求最大值、求平均值、统计负数的个数、打印所有偶数……这些不同的需求，全部复用同一个list_traverse，只需要换回调函数。这才是“求和”这道题背后真正值得修炼的功力。C 语言虽然不像高级语言那样有内置的高阶函数，但函数指针给了我们足够的表达空间，只是很多同学在学校里没有把它用起来。

5.2 一个高质量变形题：删除指定结点并返回它的值

还有一种题目让我觉得特别适合在求和练完之后做：给一个指向某个结点的指针p，要求把p从双链表中摘除，并返回这个结点的数据值。表面上是删除，但任务里隐含着“操作前先记录数据”和“保证链表不断”两个要求。

如果p不是头结点也不是尾结点，标准做法是让它的前后邻居彼此绕过它：

p->prev->next = p->next; p->next->prev = p->prev;

如果p是尾结点，那就没有p->next可以回链了，必须单独处理：

if (p->next == NULL) { p->prev->next = NULL; } else { p->prev->next = p->next; p->next->prev = p->prev; }

很多人把这个题的边界条件漏掉，本质上是因为没有把双链表的“对称性”焊死在脑子里：next和prev总是成对出现，更新时要考虑它们可能为空的情况。这道题练透了，双链表的插入删除就等于全部过关了。

最后再分享一个我自己的习惯。写链表代码时，我从不先写代码，而是先在草稿纸上画一个两行三列的链表图，每次插入、删除都在图上手动更新一次指针。等图上的指针关系全部顺通了，再上编辑器敲代码，速度和准确率都会显著提高。这个习惯听起来老派，但对付 C 语言指针，确实比任何调试器都管用。