LeetCode 148. 排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

 

归并这里我感觉有点不符合题意（不符合常数空间）。如果是快排的话呢，交换节点还是很麻烦的，所以快排交换值了（瘫.jpg）

class Solution {
public:
    
    
    
    ListNode* sortList(ListNode* head) {
        if(!head || !head->next)return head;
        
        auto fast = head;
        auto slow = head;
        auto pre = head;
        while(fast && fast->next){
            fast = fast->next->next;
            pre = slow;
            slow = slow->next;
        }
        pre->next = nullptr;
        auto l1 = sortList(head);
        auto l2 = sortList(slow);
        return merge(l1,l2);
    }
    
    
    ListNode* merge(ListNode* l1,ListNode* l2){
        if(!l1)return l2;
        if(!l2)return l1;
        if(l1->val <= l2->val){
            l1->next = merge(l1->next,l2);
            return l1;
        }
        else {
            l2->next = merge(l1,l2->next);
            return l2;
        }
    }
};

class Solution {
public:

	void Swap(ListNode *l1,ListNode *l2){
		int tmp = l1->val;
		l1->val = l2->val;
		l2->val = tmp;
	}
	void quick_sort(ListNode* head,ListNode* tail){
		if(head == tail)return;

		int pivot = head->val;
		auto p1 = head;
		auto p2 = p1->next;
		while(p2 && p2 != tail){
			if(p2->val < pivot){
				p1 = p1->next;
				Swap(p1,p2);
			}
			p2 = p2->next;
		}
		Swap(head,p1);
		quick_sort(head,p1);
		quick_sort(p1->next,tail);
	}

    ListNode* sortList(ListNode* head) {
        quick_sort(head,nullptr);
        return head;
    }
};