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小的放在前面，其余的放在后面

个人思路：

1、根据序列的第一个结点是否小于x分成两种情况，若小于x，则将整个序列看成两部分，第一部分是小于x的序列，第二部分是还未遍历过的，当我们去遍历第二部分时，将第二部分的小于x的结点放到第一部分的尾部，直到第二部分遍历完成即可，这时的第二部分就是大等于x的序列，若大等于x，则第一部分是大等于x的序列，遍历第二部分时将大等于x的结点放到第一部分尾部，遍历结束时再将这两部分颠倒一下即可

2、注意一下边界情况即可

代码：

/*
#include <stddef.h>

struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {};
};
*/
class Solution
{
public:
    ListNode *partition(ListNode *head, int x)
    {
        if (!head)
        {
            return NULL;
        }

        bool flag; //第一个结点的值是否小于x

        if (head->val < x)
        {
            flag = true;
        }
        else
        {
            flag = false;
        }

        if (flag)
        {
            ListNode *less = head;
            ListNode *before = head;
            ListNode *current = head->next;

            while (current)
            {
                if (current->val < x)
                {
                    if (before != less)
                    {
                        before->next = current->next;
                        current->next = less->next;
                        less->next = current;
                        less = less->next;
                        current = before->next;
                    }
                    else
                    {
                        less = less->next;
                        before = before->next;
                        current = current->next;
                    }
                }
                else
                {
                    before = before->next;
                    current = current->next;
                }
            }
        }
        else
        {
            ListNode *greater = head;
            ListNode *before = head;
            ListNode *current = head->next;

            while (current)
            {
                if (current->val >= x)
                {
                    if (before != greater)
                    {
                        before->next = current->next;
                        current->next = greater->next;
                        greater->next = current;
                        greater = greater->next;
                        current = before->next;
                    }
                    else
                    {
                        greater = greater->next;
                        before = before->next;
                        current = current->next;
                    }            
                }
                else
                {
                    before = before->next;
                    current = current->next;
                }
            }

            if (before != greater) //表明该链表中存在小于x的结点，将它们放到大等于x结点的前面
            {
                before->next = head;
                head = greater->next;
                greater->next = NULL;
            }
        }

        return head;
    }
};

在网上还看到另一个思路，需要消耗O(n)的内存，自己创建两个链表，分别存放小于x和大等于x的结点，遍历一遍原来的序列后，将这两个链表合并一下即可