力扣Leet Code刷题笔记(五)--面试题02.04.分割链表/86.分隔链表-CSDN博客

本文链接：https://blog.csdn.net/2301_79419488/article/details/139044768

力扣Leet Code刷题笔记(五)–面试题02.04.分割链表/86.分隔链表

这是我的刷题笔记第五篇,算是第一道中等题了吧,这道题几乎都出来了,但每次都超时折磨我啊啊啊,后来没忍住看了眼题解才发现有个小细节没加

前言

这篇文章使用c语言进行实现
这篇文章是做了两道极其相似却又略微不同的题而写,其中有一种方法可以通吃
我会在下面标出两道题的不同

我们开始吧

点此直达哦->面试题02.04.分割链表
点此直达哦->86.分隔链表

题目描述

共同的部分:
给你一个链表的头节点head和一个特定值x，请你对链表进行分隔，使得所有小于x的节点都出现在大于或等于x的节点之前。

不同之处:
面试题:你不需要保留每个分区中各节点的初始相对位置。
86题:你应当保留两个分区中每个节点的初始相对位置。

示例图

示例1:

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

示例2:

输入: head = [2,1], x = 2
输出: [1,2]

解题思路

先不考虑各节点的初始相对位置,我们开始进入thought bubble,在每种思路的结尾会重新考虑

方法一: 新链表头插尾插

**思路:**我们在学习单链表的时候,知道插入可以有头插,尾插,中间插,而这道题要求小于某个数的节点在前面,大于某个数的节点在后面.
**因此:**我们可以创立一个新链表,将小的节点插入到新链表的头部,大的节点插入到新链表的尾部,这样就能满足题目要求.

Code 代码:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;

// 新单向无头链表 小于头插, 大于尾插
// 新节点
struct ListNode* partition(struct ListNode* head, int x)
{
    ListNode* newhead = NULL;
    ListNode* ptail = NULL;
    ListNode* pcur = head;
    while (pcur != NULL)
    {
        // head insert
        if (pcur->val < x)
        {
            // empty 边界
            if (newhead == NULL)
            {
                ptail = pcur;
            }
            ListNode* pnext = pcur->next;
            pcur->next = newhead;
            newhead = pcur;
            pcur = pnext;
        }
        // back insert(no -> NULL)
        else
        {
            // empty 边界
            if (newhead == NULL)
            {
                newhead = pcur;
                ptail = pcur;
                pcur = pcur->next;
            }
            else 
            {
                ptail->next = pcur;
                ptail = pcur;
                pcur = pcur->next;
            }
        }
    }
    // 尾节点在最后指向NULL
    if (ptail != NULL)
    {
        ptail->next = NULL;
    }   
    return newhead;
}

时间复杂度: O(n),我们对链表进行了一次遍历
空间复杂度: O(1)

分析适用范围:
很明显,使用头插的方法插入小节点,那么小节点的相对位置会发生反转,如下

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

所以只能用于上述面试题对节点相对位置不做要求的题目中

方法二: 小链表大链表合并

方法二与链表的基本操作关系没那么大了
核心思路是建立并维护两个新链表,并通过尾插的方式存储

小链表: 存储所有小于x的节点
大链表: 存储所有大于或等于x的节点

然后将两个链表合并,并返回合并后的链表

注意: 使用哑节点(空节点)来简化边界条件的处理

Code 代码:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;

// 两个链表 小于放链表1, 大于等于链表2 
struct ListNode* partition(struct ListNode* head, int x)
{
    ListNode* pcur = head;
    ListNode* list_small = malloc(sizeof(ListNode));
    ListNode* list_large = malloc(sizeof(ListNode));
    list_small->next = NULL;
    list_large->next = NULL;

    // 保存头
    ListNode* head_small = list_small;
    ListNode* head_large = list_large;
    while (pcur != NULL)
    {
        if (pcur->val < x)
        {
            list_small->next = pcur;
            list_small = pcur;
        }
        else
        {
            list_large->next = pcur;
            list_large = pcur;
        }
        pcur = pcur->next;
    }
    // 处理尾节点
    list_large->next = NULL;
    // 合并
    list_small->next = head_large->next;
    return head_small->next;
}

时间复杂度: O(n),我们对链表进行了一次遍历
空间复杂度: O(1)

分析适用范围:
很明显,这种尾插的方式是不会改变所需节点的相对位置,所以适用于上面两道题的所有情况