Spider——链表排序

归并排序

时间复杂度：O(nlog(n))
空间复杂度：由于使用了递归，O(log(n))

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head==nullptr){
            return nullptr;
        }else if(head->next==nullptr){
            return head;
        }
        ListNode* fast=head;
        ListNode* slow=head;
        while(fast->next!=nullptr&&fast->next->next!=nullptr){
            slow=slow->next;
            fast=fast->next->next;
        }
        ListNode* pre=slow;
        slow=slow->next;	//右边链表起始
        pre->next=nullptr;	//左右两个链表截断
        ListNode* l=sortList(head);
        ListNode* r=sortList(slow);
        return Merge(l,r);
    }
private:
    ListNode* Merge(ListNode* l, ListNode* r){
        ListNode* res;
        //初始化链表起始节点
        if(l->val<r->val){
            res=l;
            l=l->next;
        }else{
            res=r;
            r=r->next;
        }
        //合并链表
        ListNode* tmp=res;
        while(l!=nullptr&&r!=nullptr){
            if(l->val<r->val){
                tmp->next=l;
                l=l->next;
            }else{
                tmp->next=r;
                r=r->next;
            }                
            tmp=tmp->next;
        }
        //确保两个列表剩余的连接
        if(l!=nullptr){
            tmp->next=l;
        }else{
            tmp->next=r;
        }
        return res;
    }
};

快速排序

画图有助于理解链表的前进与交换问题

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
	//交换函数
    void swap(ListNode* p1, ListNode* p2) {
        if (p1->val == p2->val) return;
        p1->val ^= p2->val;
        p2->val ^= p1->val;
        p1->val ^= p2->val;
    }
    //快速排序
    void quickSort(ListNode* left, ListNode* right) {
        if(left == right || left==NULL || right == NULL)	return;
        int t= right->val;	//作为对照点
        ListNode* pre = NULL;
        ListNode* cur = left;	//cur维护当前比最右边大的链表
        ListNode* p = left;	    //p作为扫查的指针
		
		while(p!= right){
			if(p->val < t)	
			{
				swap(cur,p);
				pre = cur;	
				cur = cur->next;
			}
			 p = p->next;	//更新
		}
		
		if(cur!=right){
			swap(cur,right);
			cur = cur->next;
		}
		quickSort(left,pre);
		quickSort(cur,right);
    }
    
    ListNode* sortList(ListNode* head) {
        ListNode* tail = head;
        while (tail != NULL && tail->next != NULL) {
            tail = tail->next;
        }
        quickSort(head, tail);
        return head;
    }
};