归并排序小结

什么是归并排序？

归并排序是用递归实现的排序方法，先将数组不断二分，直至拆分成单个；再两两按大小归并。关键词是先分后合。

分完后合并的顺序如下图所示

归并排序的执行顺序

结合代码

void merge_sort(vector<int> &nums, int l, int r, vector<int> &temp){
	if(l + 1>=r) return ;
	//递归终止条件 
	
	//分：不断 
	int m = (l+r)/2;
	merge_sort(nums, l, m, temp);
	merge_sort(nums, m, r, temp);
	
	//合：p\q双指针归并两个有序数组 
	int p = l, q = m, i = l;
	while(p<m || q<r){ 
		if(q>=r || (p<m && nums[p]<=nums[q]))
			temp[i++] = nums[p++];
		else
			temp[i++] = nums[q++];
	}
	for(i = l; i<r; ++i) nums[i] = temp[i];
}

按照代码，可以画出如下的执行顺序：

先执行第一个递归函数，不断向左分；到达递归终止条件后，向上返回，执行第二个递归函数，向右分；左右均分完后，向上执行合并函数。
关键：递归终止条件；分与合

复杂度分析

时间复杂度O(nlog(n))

分解时间 + 合并时间
$T(n)=2T(n/2)+o(n)$

划分过程是不断二分的 log(n)
合并过程需要遍历O(n)

归并排序应用

用于链表

/*
再次记忆归并排序
归并排序用于链表：如何分割？结尾指向nullptr；合并两个链表 
*/ 

class Solution {
public:
    ListNode* sortList(ListNode* head){
		return merge_sort(head);
    }

private:
    ListNode* merge_sort(ListNode* head){
		if(!head||!head->next) return head;
		
		ListNode* slow = head;
		ListNode* fast = head;
        ListNode* mid;

		while(fast && fast->next){
            mid = slow;
			slow = slow->next;
			fast = fast->next->next;
		}
		
		//如何分割？指向nullptr 
        mid->next = nullptr;
        ListNode* l = merge_sort(head);
		ListNode* r = merge_sort(slow);
		return mergeList(l, r);		
	}

	ListNode* mergeList(ListNode* l, ListNode* r){
        //不做野指针！
		ListNode* newhead = new ListNode(0);
		ListNode* dummy = newhead;
		while(l && r){
			if(l->val < r->val){
				dummy->next = l;
				l = l->next;
			}
			else{
				dummy->next = r;
				r = r->next;
			}
            dummy = dummy->next;
		}
		if(l) dummy->next = l;
		else if(r) dummy->next = r;
		
		return newhead->next;
	}
};