Leetcode 86. 分隔链表

86. 分隔链表

解题思路：

这道题第一反应就是，模拟快排算法的那个分割，但是分割之后会有问题，无法保证之前的相对顺序，所以，采用双链表解法，after指针指向比target更大的数，before指针指向比target更小的数，最后把after和before指针连起来就ok了

源代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
private:
    unordered_map<int, ListNode*> hash;
public:
    ListNode* partition(ListNode* head, int x) {
    	// 这部分是快排的那个算法，不过没啥用，就是记录一下
        /*if(!head) return head;
        ListNode* root = head;
        int index = 0;
        while(root){
            hash[index] = root;
            root = root->next;
            index ++;
        }
        int len = index;
        int left = 0, right = len - 1;
        while(left < right){
            while(left < right && hash[right]->val > x) right --;
            while(left < right && hash[left]->val < x) left ++;
            swap(hash[left], hash[right]);
        }
        ListNode* new_head = new ListNode(-1), *last = new_head;
        int i = 0;
        for(;i<len;i++){
            last->next = new ListNode((hash[i])->val);
            last = last->next;
        }
        return new_head->next;*/
        if(!head) return head;
        ListNode* root = head, *after = new ListNode(-1), *before = new ListNode(-1);
        ListNode* a_cur = after, *b_cur = before, *b_last = before, *a_last = after;
        while(root){
            if(root->val >= x){
                a_cur = new ListNode(root->val);
                a_last->next = a_cur;
                a_last = a_cur;
                a_last->next = NULL;
            }else{
                b_cur = new ListNode(root->val);
                b_last->next = b_cur;
                b_last = b_cur;
                b_last->next = NULL;
            }
            root = root->next;
        }
        b_last->next = after->next;
        return before->next;
    }
};