C++数据结构与算法 --归并排序

时间复杂度：O(N*longN)

空间复杂度：O(N)

思想：取中点，利用递归使左边和右边有序，最后按照大小将左边和右边的内容有序存储

T(N) = 2*T(N/2)+O(N) a = 2 b = 2 d = 1

logab == d 时间复杂度为O(N*logN)

void merge(int* arr, int left, int right, int mid)
{
	int len = right - left + 1;
	int *help = new int[len];
	int index = 0;
	int p1 = left, p2 = mid + 1;
	while(p1<=mid && p2<=right)
		help[index++] = arr[p1]<=arr[p2]?arr[p1++]:arr[p2++];
	while(p1<=mid)
		help[index++] = arr[p1++];
	while(p2<=right)
		help[index++] = arr[p2++];
	for(int j = 0;j<len;j++)
	{
		arr[j+left] = help[j];
	}
	delete []help;
}
void mergeSort(int *arr,int left,int right)
{
	if (left == right)return;
	int mid = left+((right-left)>>1);
	mergeSort(arr,0,mid);
	mergeSort(arr,mid+1,right);
	merge(arr, left, right, mid);
}

冒泡 选择 插入(O(N^2))这三个排序浪费了多个比较行为，但是归并排序(O(N*logN))没有浪费，归并排序每次比较的结果有序的保存到数组之中，然后和大的数组merge得到更大的有序数组 直至执行完毕

归并例题

计算小和

当前数的左边小于当前数的相加 等价于 当前数的右边有多少个大于当前数就加几个当前数

int merge(int arr[], int left, int mid, int right)
{
	int* help = new int[right - left + 1];
	int p1 = left, p2 = mid + 1, index = 0;
	int sum = 0;
	while (p1 <= mid && p2 <= right)
	{
		sum += arr[p1] < arr[p2] ? arr[p1] * (right - p2 + 1) : 0;
		help[index++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
	}
	while (p1 <= mid)
	{
		help[index++] = arr[p1++];
	}
	while (p2 <= right)
	{
		help[index++] = arr[p2++];
	}
	for (int i = 0; i < right - left + 1; i++)
	{
		arr[left + i] = help[i];
	}
	delete[]help;
	return sum;
}
//left到right范围内 既要排序又要求小和
int mergeSum(int arr[], int left, int right)
{
	if (left == right)
		return 0;
	int mid = left + ((right - left) >> 1);
	//mid左边排序求小和+mid右边排序求小和+mid左右两边合并之后求的小和
	return mergeSum(arr, left, mid) + mergeSum(arr, mid + 1, right) + merge(arr, left, mid, right);
}

逆序对问题

class Solution {
public:
	int mergeSort(vector<int>& num, int left,int right,vector<int> &v)
	{
		if (left >= right)
		{
			return 0;
		}
		int mid = left + ((right - left) >> 1);
        //获取mid左边和右边的逆序对个数
		int sum = mergeSort(num, left, mid, v) + mergeSort(num, mid + 1, right, v);
		int p1 = left, p2 = mid + 1, index = 0;
		while (p1 <= mid && p2 <= right)
		{
            //获取mid左边和右边合并之后的逆序对个数
			sum += num[p1] > num[p2] ? (mid - p1 + 1) : 0;
			v[index++] = num[p1] <= num[p2] ? num[p1++] : num[p2++];
		}
		while (p1<=mid)
		{
			v[index++] = num[p1++];
		}
		while (p2 <= right)
		{
			v[index++] = num[p2++];
		}
		copy(v.begin(), v.begin()+right-left+1, num.begin() + left);
		return sum;
	}
		
	int reversePairs(vector<int>& nums) 
	{
		int n = nums.size();
		vector<int>v(n);
		return mergeSort(nums, 0, n-1,v);
	}
};