归并排序、快速排序

- - - - - - - -

- - - -|- - - -

- -|- -|- -|- -

-|-|-|-|-|-|-|-

从上到下，对一个数组进行不断划分找中值，这便是快速排序；从下到上看，子项分别插入排序-->合并，这便是归并排序。其实两者是相通的。

排序的稳定性是指如果在排序的序列中，存在前后相同的两个元素的话，排序前和排序后他们的相对位置不发生变化

归并排序：

对于一个数字序列，它越接近已排好序的状态，插入排序的效率越高。对已经排好序的数列，插入排序只用比较n-1次就可以了。

void merge_sort(int *pArr, int len)
{
　　//系数检查
　　if(NULL == pArr || len < 1)
　　{
　　　　return;
　　}
　　int *gArr = (int *)malloc(len * sizeof(int));
　　//库函数调用检查
　　if(NULL == gArr)
　　{
　　　　return;
　　}
　　merge_sort_index(pArr, 0, len - 1, gArr);
　　free(gArr);
}
void merge_sort_index(int *pArr, int lIndex, int rIndex, int *gArr)
{
　　if(lIndex == rIndex)
　　{
　　　　return;
　　}
　　int mIndex = (lIndex + rIndex)/2; //<-- 整数除
　　merge_sort_index(pArr, lIndex, mIndex, gArr);
　　merge_sort_index(pArr, mIndex + 1, rIndex, gArr);
　　merge_array(pArr, lIndex, mIndex, rIndex, gArr);
}
void merge_array(int *pArr, int left, int mid, int right, int *gArr)
{
　　int i, j, k;
　　i = left;
　　j = mid + 1;
　　k = 0;
　　while(i <= mid && j <= right) //<-- i <= mid && j <= right
　　{
　　　　if(*(pArr + i) <= *(pArr + j))
　　　　{
　　　　　　gArr[k++] = pArr[i++];
　　　　}
　　　　else
　　　　{
　　　　　　gArr[k++] = pArr[j++];
　　　　}
　　}
　　while(i <= mid)
　　{
　　　　gArr[k++] = pArr[i++];
　　}
　　while(j <= right)
　　{
　　　　gArr[k++] = pArr[j++];
　　}
　　memcpy(pArr + left, gArr, k * sizeof(int)); //<-- pArr + left
}

归并排序稳定，最好、最坏和平均时间复杂度都是O(nlogn)，而空间复杂度是O(n)

快速排序：

这个就简单了，就是对找中值这个过程进行分治,而找中值常用的就是挖坑填值的方法

//0, len-1
void quick_sort(int *pArr, int left, int right)
{
　　//参数检查
　　if(NULL == pArr)
　　{
　　　　return;
　　}
　　//递归中断条件
　　if(left >= right)
　　{
　　　　return;
　　}

　　int i, j, temp;
　　i = left;
　　j = right;
　　temp = pArr[i]; //挖坑

　　while(i < j)
　　{
　　　　while(i < j && temp < pArr[j]) j--; //寻找可以填的值
　　　　if(i < j) pArr[i++] = pArr[j]; //i++ //填值，同时挖坑
　　　　while(i < j && temp >= pArr[i]) i++; //寻找可以填的值
　　　　if(i < j) pArr[j--] = pArr[i]; //j-- //填值，同时挖坑
　　}
　　pArr[i] = temp; //添坑<-->中值

　　//中间数据完成排序
　　quick_sort(pArr, left, i-1); //i-1
　　quick_sort(pArr, i+1, right); //i+1
}

快速排序不稳定，时间复杂度 最理想 O(nlogn) 最差时间O(n^2)