148. 排序链表 递归或迭代

如果要求O1空间则只能迭代，递归调用函数会浪费logn的空间。

链表排序的大体思路：

类比数组归并排序

1、递归：

每次用快慢指针找出链表中点，然后递归下去，每层归并排序。

利用虚节点当链表首部，进行拼接链表，由于我们只是改变链表的引用，没有另外开辟空间，所有空间只是递归浪费的logn层空间。

2、迭代：

相当于搜索树上自底向上跑，倒数第i层一定是每相邻的 (1<<(i-1))归并排序。

具体细节看代码。

 

自顶向下递归 0logn空间

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode * merge(ListNode* head){
        if(head == nullptr || head->next == nullptr)return head;
        ListNode *fast = head,*slow = head;
        while(fast -> next && fast -> next -> next){
            fast = fast -> next -> next;
            slow = slow -> next;
        }
        ListNode *head2 = slow->next;
        slow -> next = nullptr;//断开链表，两边分开处理
        head = merge(head);
        head2 = merge(head2);
        //现在左右链表均排好序了，归并合并即可。
        
    }
    ListNode* sortList(ListNode* head) {
    	 //while(head){cout<<head->val<<" ";head = head->next;}cout<<endl;
        if(head == nullptr)return head;
        head = merge(head);
        return head;
    }
};

自底向上迭代  O1空间

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* merge(ListNode* head,ListNode* head2){
		ListNode *tmp=new ListNode(0),*ans=tmp;
	    while(head != nullptr || head2 != nullptr){
	        if(head2 == nullptr || ( head != nullptr && (head->val < head2 -> val) )){
	            tmp->next = head;
	            head = head -> next;
	        }else{
	            tmp->next = head2;
	            head2 = head2 -> next;
	        }
	        tmp = tmp -> next;
	    }
	    return ans->next;
	}
	ListNode* split(ListNode* tmp,int n){
		--n;
		while(n-- && tmp){
			tmp=tmp->next;
		}
		if(!tmp)return nullptr;
		ListNode* tp = tmp->next;
		tmp->next=nullptr;
		return tp;
	}
	ListNode* sortList(ListNode* head) {
        if(head == nullptr)return head;
        int len=0;
        ListNode* dummy=new ListNode(0);
		ListNode* cur=head;
		ListNode* L,* R;
		dummy->next=head;
        while(head){
        	len++;
        	head=head->next;
		}
		head=cur;
		for(int i=1;(1<<(i-1))<=len;i++){
			cur=dummy->next;
			head=dummy;
			for(int j=1;j<=len;j+=(1<<i)){
			//	cout<<i<<" "<<j<<" - > "<<endl;
				//int L=j,R=j+(1<<i)-1;
				L=cur;
				R=split(cur,(1<<(i-1)));
				cur=split(R,(1<<(i-1)));
				head->next = merge(L,R);
				while(head->next)head=head->next;
			//	cout<<"oko "<<endl;
			}
		}
        return dummy->next;
    }
};