归并排序模版+例题

归并排序

 归并排序是排序算法中最为经典的类型，采用了分治策略。时间复杂度为$O(lnog(n))$，若采用递归空间复杂度为$O(log(n))$，采用迭代则为$O(1)$。其主要步骤为：

1. 确定合并区间（相邻）
2. 有序数组合并

 其中数组的合并较为简单:(采用清华大学邓公的方法，这儿写容器的版本)

void merge(vector<int>& A,int lo ,int mid ,int hi)
{
//注意区间为  左闭右开
	int l = mid - hi,r = hi - mid;
	vector<int>	B(A.begin(),A.begin()+l);   //复制左半边
	int i = 0 ,j = 0,t=0;
	while(i < l || j < r)
	{
		//邓公特别喜欢使用“下标哨兵”的思想，这儿的 j>=r 代表右侧的已经走完，则一定添加左侧元素
		if(i < l && (j >= r || B[i] <= A[j+r])) A[t++] = B[i++];
		if(j < r && (i >= l || B[i] > A[j+r])) A[t++] = A[r+j++];
	}
}

 而链表合并反而更简单，不过取中值则使用快慢指针：

    ListNode* merge(ListNode* a,ListNode* b){
        ListNode* dummy = new ListNode(0);
        ListNode* cur = dummy;
        while(a || b)
        {
            if(a && (!b || a->val <= b->val)) cur = cur->next = a,a = a->next;
            if(b && (!a || b->val < a->val)) cur = cur->next = b, b = b->next;
        }
        return dummy->next;
    }

    ListNode* sortList(ListNode* head) {
        if(!head||!head->next) return head;
        ListNode* dummy = new ListNode(0);dummy->next = head;
        ListNode* slow = dummy;
        ListNode* fast = slow->next;
        while(fast&&fast->next){
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode* right = slow->next;
        //左侧尾部设置为nullptr
        slow->next = nullptr;
        ListNode* lo = sortList(head);
        ListNode* hi = sortList(right);
        return merge(lo,hi);
    }

例题应用:
剑指offer 65. 数组中的逆序对：
过程和mergeSort一样，合并的时候，若右侧的要插到左边，则将结果加上当前左侧剩余的长度，注意merge的时候为左闭右开[i,m)。

	int res = 0;
    void merge(vector<int>& nums,int lo,int mid ,int hi)
    {
        vector<int> A(nums.begin()+lo,nums.begin()+mid);
        int i = 0 ,j = 0,t=lo;
        int m = mid - lo ,n = hi - mid;
        while(i < m || j < n)
        {
            if(i < m && (j >=n || A[i] <= nums[mid+j])) nums[t++] = A[i++];
            if(j < n && (i >=m || A[i] > nums[mid+j])){
                nums[t++] = nums[mid+j++];
                res += m - i;
            }
        }
    }
    void mergeSort(vector<int>& nums,int lo ,int hi)
    {
        if(hi - lo < 2) return;
        int mid = (lo + hi) >> 1;
        mergeSort(nums,lo,mid);
        mergeSort(nums,mid,hi);
        merge(nums,lo,mid,hi);
    }
    
    int inversePairs(vector<int>& nums) {
        mergeSort(nums,0,nums.size());
        return res;
    }