【leetcode】Partition List

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,
Given 1->4->3->2->5->2 and x = 3,
return 1->2->2->4->3->5.

---

不是很麻烦的一道题，首先找到链表中第一个比x大或者等于x的数，它的指针存放在before_p中，那么后面比x小的数都插入到它前面就可以了。在遍历的过程中，还要用指针front_p保存p的前一个指针，方便删除p所指向的节点。开始时候没有用这个指针，后来发现当删除的元素在链表结尾的时候，这个指针是必须的。

一种特殊的情况是需要头插的时候，比如

1. 给定的序列是2->1，给定的x是2，此时1要被头插到2前面去；

2. 给定的序列是2->3->1，x是3的时候1只需插入到2的后面，要注意这两种情况的区别。

利用判断before_p == head && before_p->val >= x，就可以甄别出要头插的情况了。因为在before_p == head时，有两种情况，一种是before_p指向的元素确实比x大或者相等，对应上述的第一种情况，需要头插；另外一种before_p指向的元素比x小，只需要把元素插入到before_p后面就可以了，对应于上述的第二种情况。

WA了一次才发现的，一般好难想到这一点>.<

代码：

#include <iostream>
#include <stdlib.h>
using namespace std;

struct ListNode {
     int val;
     ListNode *next;
     ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode *partition(ListNode *head, int x) {
        ListNode* p = head;
        ListNode* before_p = head;
        ListNode* front_p;
        
        //找到链表中第一个大于等于x的数，以后比x小的数都插在它后面
        while(p!= NULL && p->val < x){
            before_p = p;
            p = p->next;
        }
        
        if(p !=NULL)
        {
            while(p != NULL){
                //找到一个比x小的数，要挪动它
                if(p->val < x){
                    int value = p->val;
                    //删除比x的小的数的节点
                    if(p->next != NULL)
                    {
                        ListNode* temp = p->next;
                        p->val = temp->val;
                        p->next = temp->next;
                        free(temp);
                    }
                    else{
                        front_p->next = NULL;
                        ListNode* temp = p;
                        p = NULL;
                        free(temp);
                    }
                    //删除掉的节点插入到before_p后面
                    ListNode* new_node= (struct ListNode*)malloc(sizeof(struct ListNode));
                    new_node->val = value;

                    if(before_p == head && before_p->val >= x){//头插
                        new_node->next = head;
                        head = new_node;
                        before_p = head;
                    }
                    else//不需要头插
                    {
                        new_node->next = before_p->next;
                        before_p->next = new_node;
                        before_p = new_node;
                    }
                }
                else{
                    front_p = p;
                    p = p->next;
                }
            }
        }
        return head;
    }
};

int main(){
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = 2;
    struct ListNode*next = (struct ListNode*)malloc(sizeof(struct ListNode));
    next->val = 1;
    head->next = next;
    next->next = NULL;
    /*struct ListNode* node3 = (struct ListNode*)malloc(sizeof(struct ListNode));
    node3->val = 3;
    next->next = node3;
    struct ListNode* node4 = (struct ListNode*)malloc(sizeof(struct ListNode));
    node4->val = 2;
    node3->next = node4;
    struct ListNode* node5 = (struct ListNode*)malloc(sizeof(struct ListNode));
    node5->val = 5;
    node4->next = node5;
    struct ListNode* node6 = (struct ListNode*)malloc(sizeof(struct ListNode));
    node6->val = 2;
    node5->next = node6;
    node6->next = NULL;*/

    Solution solution;
    ListNode* h = solution.partition(head,2);
    cout <<"dfs"<<endl;
    while(h != NULL)
    {
        cout << h->val<<endl;
        h = h ->next;
    }
}