入门级题解86. 分隔链表

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

你应当 保留 两个分区中每个节点的初始相对位置。

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

输入：head = [2,1], x = 2 输出：[1,2]
提示：

链表中节点的数目在范围 [0, 200] 内
-100 <= Node.val <= 100
-200 <= x <= 200

读题

所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

1 2 3 6 5 4 3 2 4 3 2 5 x=4

1 2 3 3 2 3 2 6 5 4 4 5

保留两个分区中每个节点的初始相对位置。

不要改变顺序

思路
遍历，建两个新链表，然后小的放一个，大于等于的放一个，最后直接连在一起
shit 错误的，太复杂了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if(!head || head->next == nullptr){
            return head;
        }
        ListNode* b = new ListNode;//存放小于x的节点
        ListNode* s = b;//用来遍历b
        ListNode* s1 = b;//最后的遍历
        ListNode* p =  head;
        ListNode* big =  new ListNode;//存放大的
        ListNode* q = big; 
        ListNode* newlist =  new ListNode(0,big);
        ListNode* newlist1 =  newlist;
        //遍历head
        while(p){
            if(p->val < x){
                s->val = p->val;
                s->next = new ListNode;
                s = s->next;
            }
            else{
                q->val = p->val;
                q->next = new ListNode;
                q = q->next;
            }
            p = p->next;
        }
        while(newlist1){
            if(newlist1->next->next == nullptr){
                newlist1->next = nullptr;
            }
            newlist1 = newlist1->next;
        }
        while(s1->next->next){
            s1 = s1->next;
        }
        if(s1&&s1->next!=nullptr)
        s1->next = newlist->next;
        return b;
    }
};

看看官方题解，恍然大悟
就是思路我是把大的小的都新建一个链表存起来，官方题解是说新建链表完了，然后判断head，如果小于，就把head给small，大于就给big。。。
1.初始状态

2.1小于3

if (head->val < x) {
                small->next = head;
                small = small->next;

1 4 3 2 5 2

3.4大于3

large->next = head;
large = large->next;

4.大于3

5.小于3
这里smallHead变了，可以看到没有大于的

6.大于3

7.小于3

这里比较关键，可以看到2小于3，head’已经遍历结束了，但largeHead里还有 2，这是因为小于那边完了直接结束，我们用的是large->next = head;，所以后面加了处理语句

large->next = nullptr;

这个就让large只保存最后的大于的那个节点值，其他的都删掉了

为什么small不需要呢，看题目要求，是让小的放在前面，所以small不需要加这个语句处理

最后的处理

small->next = largeHead->next;
return smallHead->next;

small把largehead的接过来，返回smallHead->next

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* small = new ListNode(0);
        ListNode* smallHead = small;
        ListNode* large = new ListNode(0);
        ListNode* largeHead = large;
        while (head != nullptr) {
            if (head->val < x) {
                small->next = head;
                small = small->next;
            } else {
                large->next = head;
                large = large->next;
            }
            head = head->next;
        }
        large->next = nullptr;
        small->next = largeHead->next;
        return smallHead->next;
    }
};