归并排序、快速排序

归并排序

对于一个数字序列，它越接近已排好序的状态，插入排序的效率越高。对已经排好序的数列，插入排序只用比较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
}

快速排序：

这个就简单了，就是对找中值这个过程进行分治

//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
}