（2）认识复杂度O(NlogN)的排序算法（C语言数据结构及算法）

一、使用二分法求一个无序数组中的最大值

（1）工作原理：

使用递归函数，将无序数组不断二分成左右两个部分，每次递归返回左右两侧最大的数，直到无法划分为止。递归过程类似er于后序遍历的压栈过程。

（2）代码表示：

/*二分法求无序数组arr[L……R]中的最大值*/
int process(int* arr, int L, int R)
{
	if (L == R)
		return arr[L];
	int mid = L + ((R - L) >> 1);//求中点，这种写法可防溢出
	int leftMax = process(arr, L, mid);
	int rightMax = process(arr, mid + 1, R);
	return leftMax > rightMax ? leftMax : rightMax;
}


int getMax(int* arr, int len)
{
	return process(arr, 0, len - 1);
}

（3）重点代码解析

 求中点的过程中若使用下面的写法，很容易导致溢出的现象发生：当L和R都足够大时，L+R会超出范围，若采用mid = L+(R-L)/2这种写法，可以避免出现L+R。

int mid = (L+R)/2;

---

二、递归函数的时间复杂度

（1）master公式

 

其中T(N)为母问题的规模（数据量），a为递归调用次数，T(N/b)为子问题的规模。

上例中符合master公式下a=2，b=2，d=0的情况，因为有2次递归（leftMax和rightMax），每次把数据量分为原来的一半，除递归调用外没有其他循环，时间复杂度为O(1)。

需要注意的是，若子问题规模不相等，master公式不成立。

（2）时间复杂度

  时，时间复杂度为;

  时，时间复杂度为

  时，时间复杂度为

上例满足第二种情况，时间复杂度为O(N)，时间复杂度的指标等同于遍历寻找最大值。

---

三、归并排序

（1）思路

采用分治法，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

简单来说就是使左边有序，右边有序，然后使整体有序。

（2）代码实现

/*二路归并排序*/
void merge(int* arr, int L, int M, int R)//将左右两侧的数字按大小并入辅助数组help
{
	int* help = (int*)malloc(sizeof(int) * (R - L + 1));
	int i = 0;
	int p1 = L, p2 = M + 1;
	while (p1 <= M && p2 <= R)
		help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
	while (p1 <= M)
		help[i++] = arr[p1++];
	while (p2 <= R)
		help[i++] = arr[p2++];
	for (int k = 0; k < i; k++)
		arr[L + k] = help[k];
}
void process(int* arr, int L, int R)//递归使mid左右两侧有序
{
	if (L == R)
		return;
	int mid = L + ((R - L) >> 1);
	//左右两侧进行递归拆分
	process(arr, L, mid);
	process(arr, mid + 1, R);
	//再将arr中的左右两部分合并为有序的，L到mid为左侧部分，mid+1到R是右侧
	merge(arr, L, mid, R);
}
void mergeSort(int* arr, int len)
{
	if (arr == NULL && len < 2)
		return;
	process(arr, 0, len - 1);
	for (int k = 0; k < len; k++)
		printf("%d ", arr[k]);
}

（3）时间复杂度和空间复杂度

时间复杂度依据master公式可知为O(N*logN)，空间复杂度为O(N)，因为使用了辅助数组help。

---

四、归并法求解小和问题

（1）小和问题概念

在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。要求使用二路归并的方法求一个数组的小和。
例子：
[1,3,4,2,5]
1左边比1小的数，没有；
3左边比3小的数，1；
4左边比4小的数，1、3；
2左边比2小的数，1；
5左边比5小的数，1、3、4、2；
所以小和为1+1+3+1+1+3+4+2=16

（2）代码实现

/*小和问题*/
int sortMerge(int* arr, int L, int mid, int R)
{
	int* help = (int*)malloc(sizeof(int) * (R - L + 1));
	int i = 0, p1 = L, p2 = mid + 1;
	int res = 0;
	while (p1 <= mid && p2 <= R)
	{
		res += arr[p1] < arr[p2] ? (R - p2 + 1) * arr[p1] : 0;
		help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
	}
	while (p1 <= mid)
		help[i++] = arr[p1++];
	while (p2 <= R)
		help[i++] = arr[p2++];
	for (int k = 0; k < i; k++)
	{
		arr[L + k] = help[k];
	}
	return res;
}

int sortProcess(int* arr, int L, int R)
{
	if (L == R)
		return 0;
	int mid = L + ((R - L) >> 1);
	return sortProcess(arr, L, mid) + sortProcess(arr, mid + 1, R) + sortMerge(arr, L, mid, R);
	//左侧排序并且求出小和的数量+右侧排序并且求出小和的数量+将左右侧合并时产生小和的数量
}

int smallSum(int* arr,int len)
{
	if (arr == NULL || len < 2)
		return 0;
	return sortProcess(arr, 0, len - 1);
}

---

五、快速排序

（1）思路

参考http://t.csdn.cn/xGurn ，先找到一个基准数，然后把所有小于它的数放在左边，所有大于它的数放在右边，基准数放在中间，此时基准数的位置与最终得到的有序数组中该数的位置一样，然后分别对基准数左边和右边的数进行递归，最终所有数都会到达有序位置。

（2）代码实现

/*快速排序2.0*/
void quickSort(int* arr, int L, int R)
{
	if (L >= R)
		return;
	int i, j, base, temp;
	i = L;
	j = R;
	base = arr[L];//取最左侧的数为基准数
	while (i < j)
	{
		while (arr[j] >= base && i < j)
			j--;
		while (arr[i] <= base && i < j)
			i++;
		if (i < j)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	arr[L] = arr[i];//基准数归位
	arr[i] = base;
	quickSort(arr, L, i - 1);//递归左侧（小于base）
	quickSort(arr, i + 1, R);//递归右侧（大于base）
}

（3）快速排序优化
上面的代码是快速排序2.0版本，缺陷在于当数组本身有序时，无法实现对左侧和右侧两个子序列的递归，因为所有数都大于基准数，每次递归实际上就是对整个数组递归，最差的时间复杂度为;当基准数刚好是中位数时，左右两侧的子序列长度相等时，为最优时间复杂度。

快速排序3.0的做法是不直接指定基准数，而是在序列中随机选择一个数作为基准数，这样可以避免最差时间复杂度情况的发生，此时时间复杂度为

快速排序的空间复杂度是。其中最优的空间复杂度出现在base值刚好为中点时，为，最差的空间复杂度出现在base为最大值或最小值时，为，经过数学计算可以得到随机情况下空间复杂度收敛于。