单向链表头结点与无头结点详解：设计逻辑与指针操作

1. 从一次"头结点困惑"说起：单向链表的第一道坎

我在给团队新人讲数据结构的时候，有个问题几乎每次都会被问到：为什么同样叫单向链表，有的写法要弄一个"头结点"，有的写法直接定义一个指针指着第一个节点就行？到底有没有头结点，写出来怎么还不太一样？

这个问题看起来很简单，但实际操作中它特别容易把人绕晕。我自己早年写链表的时候也在这上面栽过跟头：无头结点版本的头插法，函数里怎么改都不对，返回去看头指针还是原来的值；后来换成有头结点的写法，才发现"哨兵节点"这东西是真的省心。但省心归省心，LeetCode 上一做题，给的链表又全是没有头结点的，导致我一度在两个版本之间来回切换的时候经常写错。

这篇就把 DS-2 有头/无头结点的单向链表一次性聊透。不光是贴代码，重点是讲清楚两种写法背后的设计逻辑、指针操作差异、边界条件处理，以及工程和算法场景里分别应该怎么选。文章里我会用 C 语言来写核心代码，因为这个话题本质上是关于内存和指针的，C 最直观。

1.1 有头结点和无头结点到底差在哪

先统一一下概念，因为很多人把"头结点"和"头指针"混着叫，一混就乱。

• 头指针：是一个指针变量，存放链表中第一个有效节点的地址。
• 头结点：是一个真实存在的节点，但它不存放有效数据，只是为了操作方便而存在。

无头结点的单向链表，就是最朴素的那种：一个 head 指针指向第一个保存数据的节点，如果链表为空，head 就是 NULL。

有头结点的单向链表，则是在真正的第一个数据节点前面，额外挂了一个节点。这个节点的 data 域可以顺手存一些元信息（比如链表长度），也可以直接闲着不用，关键是它的 next 指到真正的第一个数据节点。head 指针指向这个头结点，而不是指向第一个数据节点。

这两种写法在"链表为空"的时候差异最明显：无头结点版本里，空链表就是 head == NULL；有头结点版本里，空链表是 head != NULL 但 head->next == NULL。这个差异是所有后续操作逻辑分岔的根源。

注意：头结点不是头指针。头结点是节点，头指针是变量。很多教材用 L 表示头指针，用 L->next 表示第一个数据节点；如果你把"头结点"和"第一个数据节点"搞混，后面所有操作都会写错。

1.2 为什么"头结点"两个字背后藏着一整套设计选择

我当年学的时候有个特别大的疑惑：既然无头结点更简单，为什么还要整一个头结点出来？答案其实藏在一个很细的操作里——删除。

无头结点版本里，如果要删除的是第一个节点，链表新的头指针应该指向第二个节点。这个操作会改变 head 指针本身的值。而在 C 语言中，函数参数是值传递，你在函数里改了 head，外面根本不知道，必须用二级指针，或者用返回值把新 head 传出去。这就是无头结点版本最烦人的地方。

有头结点版本就没有这个问题。不管删除的是第一个、中间还是最后一个有效节点，需要修改的永远是"某个节点的 next 指针"，head 这个指针变量本身永远不变。这样一来，函数里只需要传一级指针，逻辑上统一了很多。

所以，有头结点的本质，是在用一个小小的"空节点"来换取"所有操作的代码模式完全一致"。插入也是、删除也是、遍历也是，不用担心"当前位置是不是开头"这种特殊情况。对于工程上需要长期维护、频繁改动的链表来说，这一点非常值。

2. 深入拆解：两个版本在内存布局和指针语义上的真正差异

这一节我们不只看代码，还要把内存图画出来。因为链表题写错，九成都是心里没有内存图，指针指来指去全凭感觉。

2.1 无头结点版本：头指针就是第一个节点

无头结点版本的典型定义：

c复制typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node *head = NULL; // 空链表

内存上，head 是一个局部变量（或者全局变量），它存的是一个地址。这个地址要么是 NULL，要么是第一个节点的地址。第一个节点的 next 存第二个节点的地址，以此类推。

这种结构最直观，但有个隐含问题：head 这个变量本身和节点不在同一条链上。head 是"外部的一个指针"，你操作链表时，必须明确区分"我要改节点里的 next"还是"我要改 head 这个指针"。

比如头插一个节点：

c复制Node *new_node = (Node *)malloc(sizeof(Node));
new_node->data = 42;
new_node->next = head;  // 新节点指向原来的第一个节点
head = new_node;        // 更新头指针

这两步缺一不可。如果你在函数里操作：

c复制void insert_head(Node *h, int val) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    new_node->data = val;
    new_node->next = h;
    h = new_node; // 修改的是形参，外面的 head 没变
}

那调用 insert_head(head, 42); 之后，外面的 head 还是指向原节点，新节点就丢了。正确做法是返回值：

c复制Node *insert_head(Node *h, int val) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    new_node->data = val;
    new_node->next = h;
    return new_node;
}

head = insert_head(head, 42);

或者用二级指针：

c复制void insert_head(Node **h, int val) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    new_node->data = val;
    new_node->next = *h;
    *h = new_node;
}

insert_head(&head, 42);

这个"一级指针没法更新头指针"的坑，几乎每个刚写链表的人都踩过。理解了内存布局，你会意识到这不是语法问题，而是"你要修改的对象到底是谁"的问题。

2.2 有头结点版本：哨兵节点的价值

有头结点版本的定义：

c复制typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node *head = (Node *)malloc(sizeof(Node));
head->next = NULL; // 空链表
head->data = 0;    // 可以存表长，也可以不用

这里 head 指向的是一个哨兵节点。链表为空时，哨兵节点的 next 是 NULL；链表非空时，哨兵节点的 next 指向第一个真正有数据的节点。

哨兵节点的存在，让"第一个数据节点"不再是特殊位置。插在头部，相当于插在 head 这个哨兵节点的后面；删除头部数据节点，相当于删除 head->next。这两种操作和"在中间插入/删除"的代码模式完全一样，都是通过"当前节点的 next"来操作后继节点。

这在工程上非常好维护：你不用写"如果是删除第一个节点，就特殊处理 head"这种分支。代码的分支少了，bug 就少了，review 的人也省心。

但哨兵节点也有代价：多占一个节点的内存（通常可以忽略）；遍历的时候你得记得跳过头结点，从 head->next 开始；如果你把 head 本身的值误当作数据用，会引发诡异问题。

2.3 空表状态下的行为对比

我用一张表把两种写法在不同操作下的表现列出来，方便对照记忆：

这张表值得贴在你电脑前面。当你看到"为什么这段代码在空表时会崩"，很多情况下都是因为把两种写法的判空条件搞混了。

3. 核心操作逐行实战：插入、删除、反转的完整写法

到这里进入实操环节。我假设你已经理解了上面的内存布局，下面直接看代码。每一段我都会标注容易写错的地方和为什么。

3.1 无头结点的头插法：指针指向是第一道坎

无头结点版本的头插法，核心顺序就一句话：先让新节点指向原来的头，再让头指向新节点。顺序反了就断链。

c复制Node *insert_head(Node *head, int val) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    if (new_node == NULL) {
        return head; // 分配失败，保持原链表
    }
    new_node->data = val;
    new_node->next = head;
    return new_node; // 新的头就是这个新节点
}

注意最后的返回语句。如果你写成 void 函数，就只能用二级指针：

c复制void insert_head(Node **head, int val) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    if (new_node == NULL) {
        return;
    }
    new_node->data = val;
    new_node->next = *head;
    *head = new_node;
}

我个人的建议是：无头结点版本的链表，所有可能改变头指针的操作，一律用二级指针接口。因为返回值你可能忘记接，但二级指针你传错了编译器会直接报类型不匹配的警告，不容易瞒过去。

3.2 有头结点的尾插法：遍历到尾部再挂新节点

有头结点版本的尾插法，整体思路是：从头结点开始，一路找到 next 为 NULL 的那个节点，然后把新节点挂在它后面。

c复制void insert_tail(Node *head, int val) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    if (new_node == NULL) {
        return;
    }
    new_node->data = val;
    new_node->next = NULL;

    Node *p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = new_node;
}

这里最值得关注的是 while (p->next != NULL) 而不是 while (p != NULL)。原因很简单：我们要找的是"最后一个节点"，而不是"NULL 的位置"。如果写成 while (p != NULL)，循环结束之后 p 等于 NULL，你就丢失了"上一个节点"的信息，新节点不知道挂在哪里。

这也是尾插法在无头结点版本里比较麻烦的原因：如果链表为空，你需要直接修改 head 指针本身。很多人的代码在"空表尾插"时崩溃，就是因为忘了这个特判。有头结点版本不存在这个特判，空表时 head->next 就是 NULL，循环一次都不走，直接把新节点挂到 head->next 上。

3.3 删除指定值的节点：判断头结点的两种写法

先看无头结点版本，删除第一个值等于 val 的节点：

c复制Node *delete_value(Node *head, int val) {
    if (head == NULL) {
        return NULL;
    }

    // 如果要删的是第一个节点
    if (head->data == val) {
        Node *tmp = head;
        head = head->next;
        free(tmp);
        return head;
    }

    Node *p = head;
    while (p->next != NULL) {
        if (p->next->data == val) {
            Node *tmp = p->next;
            p->next = p->next->next;
            free(tmp);
            break;
        }
        p = p->next;
    }
    return head;
}

这个写法里有个细节：删除第一个节点之后，函数返回了新的 head；删除非第一个节点时，head 没有变化，但为了统一，函数最后仍然返回 head。调用方永远这么用：

c复制head = delete_value(head, 42);

如果你偷懒，写成 delete_value(head, 42); 不接返回值，并且在函数里删掉了原头节点，那你的 head 就变成悬空指针了。

再看有头结点版本，代码会干净很多：

c复制void delete_value(Node *head, int val) {
    Node *p = head;
    while (p->next != NULL) {
        if (p->next->data == val) {
            Node *tmp = p->next;
            p->next = p->next->next;
            free(tmp);
            return;
        }
        p = p->next;
    }
}

是不是简单很多？因为 head 指针本身永远不需要变，你只需要操作 p->next。而且也不用特判"第一个节点"，因为第一个节点的前面永远有一个哨兵节点 head。这就是头结点带来的统一性。

3.4 反转链表：头结点版本的一个小便宜

反转链表是面试高频题。无头结点版本的经典写法：

c复制Node *reverse(Node *head) {
    Node *prev = NULL;
    Node *cur = head;
    while (cur != NULL) {
        Node *next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

三指针法：prev 表示"已经反转好的部分链表的头"，cur 是当前要处理的节点，next 先保存 cur 原本的后继，防止 cur->next 指到 prev 之后找不到后面的节点。循环结束后，prev 就是新链表的头。

有头结点版本的反转，思路有微小差别。我们最终要让 head->next 指向新的第一个数据节点：

c复制void reverse(Node *head) {
    Node *p = head->next;   // 第一个有效节点
    head->next = NULL;      // 先把哨兵节点和新链表断开

    while (p != NULL) {
        Node *next = p->next;
        p->next = head->next;
        head->next = p;
        p = next;
    }
}

这段代码每次取一个节点 p，把它插到哨兵节点后面，相当于一直在做头插。循环结束后，原链表的所有节点都被重新按头插法挂到了 head 后面，自然就反转了。

这里有个小便宜：因为有头结点，你不需要返回新的头指针，直接在原链表上操作就行，外部代码不用改。而无头结点版本反转之后，必须用返回值把新的头指针接回去。

4. 边界条件才是链表的灵魂：空表、单节点、尾节点怎么处理

链表题的 bug 高发区，永远是边界条件。不是代码不会写，而是空表、单节点、尾节点这几种情况经常被大脑自动忽略。

4.1 空表与单节点的遍历终止条件

很多人在遍历链表时写出类似这样的代码：

c复制for (Node *p = head; p != NULL; p = p->next) {
    // 处理 p
}

这在没有头结点时是标准的。但如果你换成有头结点版本，还这么写，就会把头结点也遍历进去。正确的有头结点版本：

c复制for (Node *p = head->next; p != NULL; p = p->next) {
    // 处理 p
}

别小看这个 head->next 的区别。你在 LeetCode 上刷题时，给的是无头结点链表的头指针，循环从 head 开始；你自己工程里用的是有头结点链表，起点要往后挪一位。这个习惯如果不建立起来，两道题写完就会开始混。

单节点的情况同样值得警惕。无头结点链表只有一个节点时，head != NULL 且 head->next == NULL。此时如果写 while (head->next != NULL)，循环体一次都不执行，所有操作都在这个唯一节点上进行——这在删除、反转场景里通常没问题，但在查找尾节点时就可能返回错误结果。

4.2 删除尾节点时的 pre 指针处理

删除尾节点是另一个高频崩溃现场。无头结点版本，如果要删除的是尾节点，你的 pre 指针必须恰好停在倒数第二个节点。很多人会写成：

c复制Node *p = head;
while (p->next != NULL) {
    p = p->next;
}
// 此时 p 指向尾节点，但尾节点的前一个节点是谁？

你丢失了前驱信息。正确写法是用一个 prev 指针跟着：

c复制Node *delete_tail(Node *head) {
    if (head == NULL) {
        return NULL;
    }
    if (head->next == NULL) {
        free(head);
        return NULL;
    }

    Node *prev = head;
    while (prev->next->next != NULL) {
        prev = prev->next;
    }
    // 此时 prev 是倒数第二个节点
    free(prev->next);
    prev->next = NULL;
    return head;
}

注意第二个 if 分支：如果链表只有一个节点，删除后头指针必须变成 NULL。这个特判在有头结点版本里是不需要的，因为哨兵节点永远存在，尾节点永远不是"唯一的节点"。

4.3 有头结点的 find/delete 代码怎么写

上面说过，有头结点版本的删除逻辑是统一的。这里我再给一个完整示例，包含查找和删除，并且处理"链表为空"和"找不到"的情况：

c复制int delete_node(Node *head, int val) {
    if (head == NULL || head->next == NULL) {
        return 0; // 空链表
    }

    Node *p = head;
    while (p->next != NULL) {
        if (p->next->data == val) {
            Node *tmp = p->next;
            p->next = p->next->next;
            free(tmp);
            return 1; // 删除成功
        }
        p = p->next;
    }
    return 0; // 没找到
}

返回值让调用方知道是否真的删除了。这个函数的边界条件只有两个：空链表、找不到。没有"删除的是第一个节点"这种特殊情况，因为有头结点的存在，第一个有效节点的前驱就是头结点本身，while 循环第一次就会检查它。

我在实际工程里几乎都采用这种风格：函数尽量返回明确的状态码，避免让调用方通过检查链表内容来推断操作结果。

5. 工程视角：面试题、LeetCode 和实际项目中到底用哪种

学链表的时候难免会有一个疑问：到底哪种写法才是"对的"？其实没有绝对的对错，看场景。

5.1 算法题中几乎都是无头结点版本

LeetCode、牛客、各种面试手写题里，链表的定义几乎都是：

c复制struct ListNode {
    int val;
    struct ListNode *next;
};

它没有哨兵节点，传给你的 head 就是第一个有效节点。这种题目你不需要考虑内存释放，不需要考虑工程维护，只需要在纯数据结构层面把逻辑写对。

所以在刷题场景中，你必须熟练掌握无头结点版本的写法，尤其是头插法的返回值、删除头节点时的特判、反转链表时的新头返回。这些基本操作如果还要临时想，面试时基本上就挂了。

我个人的建议是：刷题时先在纸上画一遍内存图，再写代码。不是每个题都画，而是画那些有"修改头指针"或"删除节点"的操作，画多了之后你会建立很强的指针直觉。

5.2 实际工程的嵌入式/底层场景更偏好哪种

回到工程场景，尤其是 C 语言开发的嵌入式、内核、网络库等领域，我更推荐有头结点版本。理由有三点：

第一，插入删除操作不需要二级指针。工程代码的接口如果充满 Node **，调用方误传一级指针的概率很高，编译报错都算好的，最怕的是传了 Node * 然后编译器只给个 warning，运行起来直接段错误。

第二，哨兵节点可以携带元信息。比如把链表长度存在哨兵节点的 data 域，求长度从 O(n) 变成 O(1)。当然这要求你每次插入删除都同步更新这个值，多写一行代码，但换来的性能收益在某些高频场景里很可观。

第三，内存管理更安全。无头结点版本在删除最后一个有效节点后，head 必须被置空，如果调用方忘记接返回值，head 就成了悬空指针。有头结点版本里，head 永远是有效的哨兵节点，你不会出现这种悬空问题。

当然，也不是说有头结点就是银弹。如果你在写一个极简的链表，内存开销非常敏感，或者你的使用者都习惯了无头结点写法，那保持无头结点也行。工程上没有银弹，只有取舍。

5.3 如何在不同写法间快速转换

我自己在从 LeetCode 模式切到工程模式时，吃过几次"起点位置搞错"的亏。后来总结出一个切换口诀：无头结点看 head，有头结点看 head->next。

具体来说：

• 判断空表：无头结点用 head == NULL，有头结点用 head->next == NULL。
• 遍历起点：无头结点从 head 开始，有头结点从 head->next 开始。
• 插入起点：无头结点要改 head 指针，有头结点只改 head->next。
• 删除起点：无头结点要返回新 head，有头结点只改 head->next。

如果你正在做的项目里两种链表都有，我建议你写两个小工具函数，统一入口：

c复制int is_empty_no_head(Node *head) {
    return head == NULL;
}

int is_empty_with_head(Node *head) {
    return head->next == NULL;
}

看起来有点傻，但真到切换代码的时候，你会发现一个好记的入口函数比什么都管用。

6. 调试与避坑：段错误、悬空指针和内存泄漏的排查链路

最后聊点实战里最常见的三个问题。每个写 C 链表的人都会遇到，区别只在于你能不能快速定位。

6.1 段错误常见位置

段错误（segmentation fault）在链表里的高频原因，我排个序：

第一，访问了 NULL 指针的 next 成员。比如：

c复制while (p != NULL) {
    if (p->data == val) { ... }
    p = p->next;
}

看起来没问题，但如果某个节点的 next 不是正常地址，或者你把 p 错误地指向了某个已释放节点，p->next 会炸。

第二，修改了不存在的节点。比如 head->next->next->next 在链表长度不够时，任何一个环节是 NULL，都会段错误。

第三，free 之后还访问。悬空指针本身不会立刻报错，但一旦那块内存被系统回收或者被其他变量覆盖，你再读就是未定义行为，表现可能是"偶尔崩、偶尔正常"，非常烦人。

排查段错误时，我一般先加打印，在每一步操作前打印当前节点的 data 和地址：

c复制printf("current node: %p, data: %d\n", (void *)p, p->data);

加了打印之后，你很快就能定位是"哪一步操作让指针变成了非法值"。定位到之后，再回头看内存图，多半会发现是"少了一次判空"或者"多走了一步 next"。

6.2 内存泄漏：只想到 free 还不够

无头结点版本里，删除头节点时如果忘了把新 head 保存下来，几乎必然泄漏；有头结点版本里，删除数据节点后如果忘了 free，也会泄漏。泄漏本身不会崩溃，但长期运行的服务会慢慢耗尽内存。

检查内存泄漏的通用手段是用 valgrind：

bash复制valgrind --leak-check=full ./your_program

它会明确指出哪一行 malloc 的节点没有被 free。这套工具在工程环境里非常有用，强烈建议在提测前跑一遍。

但如果你的链表里有循环引用（单向链表一般不会有），或者你用了递归删除，就要小心重复 free 和栈溢出。单向链表的删除最好用循环，不要用递归：

c复制void free_list(Node *head) {
    while (head != NULL) {
        Node *tmp = head;
        head = head->next;
        free(tmp);
    }
}

这个版本的优点是：先保存 next，再 free 当前节点，绝对不会把链表走丢。有头结点版本只需把入口改为从 head->next 开始，最后再 free 掉哨兵节点。

6.3 一套自己的调试技巧

最后分享一个我自己的调试习惯，特别适合链表这种指针密集型数据结构。

第一，写一个 print_list 工具函数。每次增删改后都调用，把当前链表从头到尾的 data 打出来。有头结点版本可以顺便打印表长，这样你很快就能看出链表结构是否正常。

c复制void print_list(Node *head) {
    Node *p = head;
    while (p != NULL) {
        printf("%d -> ", p->data);
        p = p->next;
    }
    printf("NULL\n");
}

无头结点版本直接传 head，有头结点版本传 head->next。打印函数的成本极低，收益极高。

第二，在每次 free 之前，先打印这个节点的地址和 data。这样就算后面出现了悬空指针，你能回头查到"这个地址已经被释放了"，快速锁定问题节点。

第三，不要相信眼睛，用 assert 辅助判断。比如在关键节点后加：

c复制assert(p->next != NULL);

如果链表结构被破坏，assert 会立刻帮你定位到代码行，不用靠运气去猜哪里断了。

这套组合拳下来，80% 的链表 bug 都能在十分钟内定位。剩下 20% 是那种"逻辑本身就对，但内存布局想错了"的问题，那就真的只能回到内存图，老老实实把每个节点的地址写出来，再逐步推演。

其实写链表这件事，写多了你会发现，真正难的不是"怎么插""怎么删"，而是"你脑海里有没有那张内存图"。有头结点和无头结点只是两种不同的构图方式，没有谁比谁高级，只有适不适合当前场景。我自己现在的习惯是：刷题用无头结点，工程代码用有头结点，中间切换时就用那句口诀——头结点看 head->next，无头结点看 head。把这个想清楚，单向链表这个坎就算彻底过去了。