数据结构进阶：哨兵位的头结点如何简化链表操作

[哨兵位的头结点](#哨兵位的头结点)
[第一题 - - - 合并两个有序链表](#第一题 - - - 合并两个有序链表)
- [方法一 - - - 不带哨兵位的头节点](#方法一 - - - 不带哨兵位的头节点)
- [方法二 - - - 带有哨兵位的头节点](#方法二 - - - 带有哨兵位的头节点)
[第二题 - - - 链表分割](#第二题 - - - 链表分割)
[总结](#总结)

💻作者简介：曾与你一样迷茫，现以经验助你入门数据结构。

💡个人主页：@笑口常开xpr 的个人主页

📚系列专栏：硬核数据结构与算法

✨代码趣语：哨兵位是数据结构中的一个特殊存在，它如同一个忠诚的卫士，守护着数据结构的边界与秩序。

💪代码千行，始于坚持，每日敲码，进阶编程之路。

📦gitee 链接：gitee

在数据结构的世界里，每一种设计都可能孕育出惊人的效率变革。你是否深思过，一组精心组织的数据究竟能创造怎样的奇迹？每一次挖掘底层原理，都是与计算机智慧的巅峰对话；每一次剖析存储模式，都在破解数据世界的终极密码。准备好迎接这场盛宴了吗？让我们一同探寻链表中哨兵位的头结点的无尽奥秘，见证它如何重塑数字时代的运行法则！

哨兵位的头结点

定义

在普通链表中，头指针直接指向第一个结点。而在带有哨兵位头结点的链表中，我们在链表的最前面额外添加一个节点，这个节点不存储实际的数据，仅仅作为一个标记，也就是所谓的 "哨兵"，即这个节点起到站岗作用，用来简化链表操作。如果一个链表有哨兵节点的话，那么线性表的第一个元素应该是链表的第二个节点。这个哨兵结点的指针域指向链表的第一个实际节点。

优势

1、统一空链表和非空链表的处理

在普通链表中，空链表和非空链表的插入、删除操作可能需要特殊处理，因为头指针在空链表时为 NULL，而非空时指向第一个节点。而使用哨兵位头结点后，无论链表是否为空，头结点始终存在，操作更加统一。

2、简化边界条件处理

在删除操作中，如果要删除第一个节点，普通链表需要修改头指针，而使用哨兵位头结点后，删除第一个节点的操作和删除其他节点的操作完全一致，无需特殊处理。

3、提高代码健壮性

哨兵位头结点减少了对空指针的判断，降低了代码出错的可能性，使代码更加健壮。

使用场景

哨兵位头结点适用于需要频繁插入和删除链表头部节点的情况下。

注意事项

（1）、哨兵位头结点不存储实际数据，它的存在仅仅是为了简化操作。

（2）、在释放链表时，需要记得释放哨兵位头结点的内存。

（3）、在遍历链表时，要从哨兵位头结点的下一个节点开始，而不是从哨兵位头结点本身开始。

第一题 - - - 合并两个有序链表

合并两个有序链表

描述：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]

输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [ ], l2 = [ ]

输出：[ ]

示例 3：

输入：l1 = [ ], l2 = [ 0 ]

输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]

-100 <= Node.val <= 100
l1 和 l2 均按非递减顺序排列

方法一 - - - 不带哨兵位的头节点

思路分析

针对这道题，可以利用链表已经有序的特性，通过比较两个链表当前节点的值，将较小值的节点依次连接起来，形成一个新的有序链表。

解题步骤

1、处理边界情况

若任一链表为空，直接返回另一链表。

2、初始化指针

使用双指针 cur1 和 cur2 分别遍历两个链表。

通过 head 和 tail 指针维护新链表的头节点和尾节点。

3、比较并合并节点
循环条件 ：同时遍历两个链表，直至其中一个链表遍历完毕。
节点选择：比较 cur1 和 cur2 的值，选择较小值的节点加入新链表。

4、尾插操作

若新链表为空（head为 NULL），初始化 head 和 tail。

否则将选中节点连接到 tail 之后，并更新 tail。

5、处理剩余节点

将未遍历完的链表的剩余部分直接连接到新链表尾部。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

javascript 复制代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    struct ListNode* cur1 = list1;
    struct ListNode* cur2 = list2;
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    if(cur1==NULL)
    {
        return cur2;
    }
    if(cur2==NULL)
    {
        return cur1;
    }
    while(cur1&&cur2)
    {
        if(cur1->val<cur2->val)
        {
            if(head==NULL)
            {
                head=tail=cur1;
            }
            else
            {
                tail->next=cur1;
                tail=tail->next;
            }
            cur1=cur1->next;
        }
        else
        {
            if(head==NULL)
            {
                head=tail=cur2;
            }
            else
            {
                tail->next=cur2;
                tail=tail->next;
            }
            cur2=cur2->next;
        }
    }
    if(cur1!=NULL)
    {
        tail->next=cur1;
    }
    if(cur2!=NULL)
    {
        tail->next=cur2;
    }
    return head;
}

复杂度分析
时间复杂度 ：O (m+n)，其中 m 和 n 分别为两个链表的长度。
空间复杂度： O (1)，仅需常数级额外空间。

方法二 - - - 带有哨兵位的头节点

思路分析

可以引入哨兵位的头结点优化合并两个有序链表的过程。哨兵位是链表中常用的技巧，能够简化边界条件处理，使代码更加简洁和健壮。

解题步骤

1、哨兵位引入

创建一个虚拟节点（哨兵位）作为合并后链表的起始点，不存储实际数据。

使用 tail 指针动态维护链表的尾部，初始时指向哨兵位。

2、比较并合并节点

同时遍历两个链表，比较当前节点的值，将较小值的节点连接到 tail 之后。

每次连接后更新 tail 指针，使其始终指向链表的最后一个节点。

3、处理剩余节点

任一链表遍历完后，将另一链表的剩余部分直接连接到 tail 之后。

4、释放哨兵位
合并完成后，哨兵位的下一个节点即为实际链表的头节点。
释放哨兵位占用的内存，避免内存泄漏。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。
下面展示代码示例。

javascript 复制代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    struct ListNode* cur1 = list1;
    struct ListNode* cur2 = list2;
    struct ListNode* guard = NULL;
    struct ListNode* tail = NULL;
    // 带哨兵位的头结点
    guard = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
    tail->next = NULL;
    while (cur1 && cur2) 
    {
        if (cur1->val < cur2->val) 
        {
            tail->next = cur1;
            tail = tail->next;
            cur1 = cur1->next;
        } 
        else 
        {
            tail->next = cur2;
            tail = tail->next;
            cur2 = cur2->next;
        }
    }
    if (cur1)
    {
        tail->next = cur1;
    } else 
    {
        tail->next = cur2;
    }
    struct ListNode* head = guard->next;
    free(guard);
    return head;
}

复杂度分析

时间复杂度 ：O (m+n)，其中 m 和 n 分别为两个链表的长度。
空间复杂度： O (1)，仅需常数级额外空间。

第二题 - - - 链表分割

链表分割

描述

现有一链表的头指针 ListNode* pHead，给一定值 x，编写一段代码将所有小于 x 的结点排在其余结点之前，且 不能改变原来的数据顺序，返回重新排列后的链表的头指针。

思路分析

要将链表按值 x 分割，可以使用两个辅助链表分别存储小于 x 的节点和大于等于 x 的节点，然后将这两个链表连接起来形成最终结果。这种方法的核心在于利用两个哨兵位头结点来简化链表操作，避免处理空链表的边界情况。

解题步骤

1、创建两个辅助链表

一个链表用于存储所有小于 x 的节点（称为 " 较小值链表"）。

另一个链表用于存储所有大于等于 x 的节点（称为 " 较大值链表"）。

2、遍历原链表

将每个节点根据其值的大小添加到对应的辅助链表尾部。

3、连接两个辅助链表

将较小值链表的尾部连接到较大值链表的头部。

将较大值链表的尾部置为 NULL，确保链表正确结束。

4、释放哨兵位头结点

释放两个辅助链表的哨兵位头结点，避免内存泄漏。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。
下面展示代码示例。

javascript 复制代码

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Partition 
{
  public:
    ListNode* partition(ListNode* pHead, int x) 
    {
        struct ListNode *lesshead, *lesstail, *greaterhead, *greatertail;
        lesshead = lesstail = (struct ListNode*)malloc(sizeof(struct ListNode));
        greaterhead = greatertail = (struct ListNode*)malloc(sizeof(struct ListNode));
        lesshead->next = lesstail->next = NULL;
        struct ListNode* cur = pHead;
        while (cur) 
        {
            if(cur->val < x)
            {
                lesstail->next = cur;
                lesstail=lesstail->next;
            }
            else 
            {
                greatertail->next = cur;
                greatertail=greatertail->next;
            }
            cur = cur->next;
        }
        lesstail->next=greaterhead->next;
        pHead=lesshead->next;
        greatertail->next=NULL;//阻止链表带环,形成循环链表
        free(lesshead);
        free(greaterhead);
        return pHead;
    }
};

代码分析

1、初始化辅助链表

创建两个哨兵位头结点 lesshead 和 greaterhead，分别作为较小值链表和较大值链表的头部。

使用 lesstail 和 greatertail 指针分别指向两个链表的尾部，初始时都指向各自的哨兵位头结点。

2、遍历原链表并分区

使用指针 cur 遍历原链表的每个节点。

若当前节点的值小于 x，将其添加到较小值链表的尾部，并更新 lesstail 指针。

若当前节点的值大于等于 x，将其添加到较大值链表的尾部，并更新 greatertail 指针。

3、连接两个链表

将较小值链表的尾部（lesstail->next）连接到较大值链表的头部（greaterhead->next）。

将较大值链表的尾部（greatertail->next）置为 NULL，防止形成环。

4、获取结果并释放内存

最终链表的头结点为较小值链表哨兵位的下一个节点（lesshead->next）。

释放两个哨兵位头结点的内存。

复杂度分析
时间复杂度 ：O (n)，其中 n 是链表的长度。
空间复杂度：O (1)，只需要常数级的额外空间。

总结

至此，关于链表的哨兵位的头结点探索暂告一段落，但你的编程征程才刚刚启航。编写代码是与计算机逻辑深度对话，过程中虽会在结构设计、算法实现的困境里挣扎，但这些磨砺加深了对代码逻辑和数据组织的理解。愿你合上电脑后，灵感不断，在数据结构的世界里持续深耕，书写属于自己的编程传奇，下一次开启，定有全新的精彩等待。小编期待重逢，盼下次阅读时见证你们更大的进步，共赴代码之约！

数 据 结 构 进 阶：哨 兵 位 的 头 结 点 如 何 简 化 链 表 操 作

数 据 结 构 进 阶：哨 兵 位 的 头 结 点 如 何 简 化 链 表 操 作

哨 兵 位 的 头 结 点

第 一 题 - - - 合 并 两 个 有 序 链 表

方 法 一 - - - 不 带 哨 兵 位 的 头 节 点

方 法 二 - - - 带 有 哨 兵 位 的 头 节 点

第 二 题 - - - 链 表 分 割

总 结

数据结构进阶：哨兵位的头结点如何简化链表操作

数据结构进阶：哨兵位的头结点如何简化链表操作

哨兵位的头结点

第一题 - - - 合并两个有序链表

方法一 - - - 不带哨兵位的头节点

方法二 - - - 带有哨兵位的头节点

第二题 - - - 链表分割

总结