86. 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的数字放在前面，大于或者等于x的放在后面，注意不要乱了原来的顺序。也是一道比较简单的题，我的第一个思路就是使用stack的特性，使用两个栈。遍历链表，小于x的放在一个栈中，大于或者等于放在另一个栈中。然后遍历两个栈，如果存放小数值的栈不为空则将该栈中的节点出栈并使用头插法连接起来，然后遍历存放大数值的栈，将其连接起来即可。

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

        ListNode* result = new ListNode(0);

        stack<ListNode*> lt;//小于x的
        stack<ListNode*> gt;//大于x的

        while(head) {
            if(head->val < x) {
                lt.push(head);
            } else {
                gt.push(head);
            }
            head = head->next;
        }

        while(!lt.empty() || !gt.empty()) {
            if(!gt.empty()) {//如果大的数没有遍历完则遍历大的
                gt.top()->next = result->next;
                result->next = gt.top();
                gt.pop();
            } else {
                lt.top()->next = result->next;
                result->next = lt.top();
                lt.pop();
            }
        }

        return result->next;
    }
};

---

第二种方法就是使用两个指针，遍历一遍链表，使用一个指针将小于x的节点连接起来，用另一个节点将大于或者等于x的节点连接起来，最后将两个链表按照小的在前，大的在后的顺序整合起来即可。

#include <iostream>
#include <stack>
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* ltDummy = new ListNode(0);
        ListNode* gtDummy = new ListNode(0);
        ListNode* ltTail = ltDummy;
        ListNode* gtTail = gtDummy;

        while(head) {
            if(head->val < x) {
                ltTail->next = head;
                ltTail = head;
            } else {
                gtTail->next = head;
                gtTail = head;
            }
            head = head->next;
        }

        ltTail->next = gtDummy->next;
        gtTail->next = NULL;//最后一个可能不为空，所以需要赋值为空

        return ltDummy->next;


        /*if(!head) {
            return NULL;
        }

        ListNode* result = new ListNode(0);

        stack<ListNode*> lt;//小于x的
        stack<ListNode*> gt;//大于x的

        while(head) {
            if(head->val < x) {
                lt.push(head);
            } else {
                gt.push(head);
            }
            head = head->next;
        }

        while(!lt.empty() || !gt.empty()) {
            if(!gt.empty()) {//如果大的数没有遍历完则遍历大的
                gt.top()->next = result->next;
                result->next = gt.top();
                gt.pop();
            } else {
                lt.top()->next = result->next;
                result->next = lt.top();
                lt.pop();
            }
        }

        return result->next;*/

    }
};

int main() {
    Solution s;


    ListNode node1(1);
    ListNode node2(4);
    ListNode node3(3);
    ListNode node4(2);
    ListNode node5(5);
    ListNode node6(2);

    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    node4.next = &node5;
    node5.next = &node6;

    ListNode* p = s.partition(&node1,3);

    while(p) {
        cout << p->val;
        cout << endl;
        p = p->next;
    }

}