小木的算法日记-LeetCode之巧用虚拟头节点：轻松解决链表分割问题-优快云博客

本文链接：https://blog.youkuaiyun.com/GetOver_/article/details/148837881

dummy=ListNode(-1)代表的就是虚拟节点的意思。

因为dummy本身就有假的虚拟的的意思，而且-1 0 NONE等值（不符合实际情况的）一般也认为是虚拟节点的标志。

分割链表


    def partition(self, head: ListNode, x: int) -> ListNode:
定义一个分割函数，其中head的类型是链表（head既可以是头节点也可以是链表）
        # 存放小于 x 的链表的虚拟头结点
        dummy1 = ListNode(-1) 建一个虚拟头节点1
        # 存放大于等于 x 的链表的虚拟头结点
        dummy2 = ListNode(-1) 建一个虚拟头节点2
        # p1, p2 指针负责生成结果链表
        p1, p2 = dummy1, dummy2       给虚拟节点配上指针
        # p 负责遍历原链表，类似合并两个有序链表的逻辑
        # 这里是将一个链表分解成两个链表
        p = head   给原先的链表也配上指针
        while p:  当p也就是指针所对应的一直有节点时进行这个循环
            if p.val >= x:
                p2.next = p 让p2所对应节点的指针与p链接，然后再让p2往前移动
                p2 = p2.next
            else:
                p1.next = p
                p1 = p1.next   同理
            # 不能直接让 p 指针前进，
            # p = p.next     
            # 断开原链表中的每个节点的 next 指针
            temp = p.next  先将指针对应的下一个节点存放再temp以免丢失
 这里进行分解时要将节点与原来的链表的关系断干净，所以不能直接将指针直接移动到下一个位置，得利用其先进行干净。
            p.next = None 然后让指针对应的节点与之后节点的关系断干净。
            p = temp   之后继续 p=p.next 往前面移动
        # 连接两个链表
        p1.next = dummy2.next  进行链接（因为再循环之外所以代表的就是于其之后的所有节点）

        return dummy1.next 然后返回分割后又链接后的链表

AI总结

巧用虚拟头节点：轻松解决链表分割问题

一、核心问题：链表分割的本质需求

题目定义

给定一个链表的头节点 head 和一个特定值 x，要求将链表分隔为两部分：

所有小于 x的节点排在前面，
所有大于或等于 x的节点排在后面，
并且保留各节点的初始相对顺序。

示例解析

输入：head = [1, 4, 3, 2, 5, 2], x = 3
输出：[1, 2, 2, 4, 3, 5]

小于 3 的节点：1, 2, 2（顺序不变），
大于等于 3 的节点：4, 3, 5（顺序不变），
最终合并为：[小节点部分] + [大节点部分]。

二、核心思路："拆分 - 合并" 的链表手术

直接在原链表上移动节点就像在复杂电路中改线，极易出错。更聪明的做法是：
化整为零，再合二为一—— 先将原链表拆成两个子链表，再按顺序合并。

创建两个子链表：
- small链表：存储所有小于 x 的节点，
- large链表：存储所有大于等于 x 的节点。
遍历拆分：
从头到尾扫描原链表，根据节点值判断归属，分别追加到对应子链表。
合并结果：
将small链表的尾部与large链表的头部连接，形成最终链表。

三、神兵利器：虚拟头节点的妙用

为什么需要虚拟头节点？

想象你要组装玩具火车：

没有虚拟头节点时，添加第一个车厢需要单独处理（比如 "如果火车头为空，就把车厢当车头"），
有了虚拟头节点（类似火车头的挂钩），不管有没有车厢，都可以统一用 "挂钩后面接车厢" 的逻辑。

虚拟头节点的核心价值：

简化边界处理：避免判断链表是否为空，
统一操作逻辑：无论链表是否为空，追加节点的代码逻辑一致，
代码更健壮：减少因边界条件漏写导致的 bug。

四、代码实战：从思路到实现

python

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def partition(self, head: ListNode, x: int) -> ListNode:
        # 1. 初始化：创建虚拟头节点和操作指针
        dummy1 = ListNode(-1)  # small链表的虚拟头节点（哨兵）
        p1 = dummy1           # p1指向small链表的尾部，负责追加节点
        
        dummy2 = ListNode(-1)  # large链表的虚拟头节点
        p2 = dummy2           # p2指向large链表的尾部
        
        p = head              # p遍历原链表
        
        # 2. 遍历原链表，拆分节点到两个子链表
        while p:
            if p.val < x:
                # 接到small链表尾部
                p1.next = p
                p1 = p1.next
            else:
                # 接到large链表尾部
                p2.next = p
                p2 = p2.next
            
            # 关键步骤：断开原链表连接，防止链表环
            temp = p.next      # 暂存下一个节点
            p.next = None      # 切断当前节点与原链表的联系
            p = temp           # 移动到下一个节点
        
        # 3. 合并两个子链表：small链表 + large链表
        p1.next = dummy2.next  # small尾部连接large头部
        
        # 4. 返回结果：跳过虚拟头节点，返回真实头节点
        return dummy1.next