第28课 - 进阶星移

1. 希尔排列

将待排序列划分为若干个组，在每一个组内进行插入排序，一整个序列基本有序，后再对整个序列进行插入排列。

例如：将n个数据元素分成d个子序。

{ R[1]，R[1+d]，R[1+2d]，…，R[1+kd] }。

{ R[2]，R[2+d]，R[2+2d]，…，R[2+kd] }。

...

{ R[d]，R[2d]，R[3d]，…，R[kd]，R[(k+1)d] }。

其中，d 称为增量，它的值在排序过程中从大到小逐渐缩小，直至最后一趟排序减为1。

程序：

#include <stdio.h>

void println(int array[], int len)

{

int i = 0;

for(i=0; i<len; i++)

{

printf("%d ", array[i]);

}

printf("\n");

}

void swap(int array[], int i, int j)

{

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

void ShellSort(int array[], int len) // O(n*n)

{

int i = 0;

int j = 0;

int k = -1;

int temp = -1;

int gap = len;

do

{

gap = gap / 3 + 1;

for(i=gap; i<len; i+=gap)

{

k = i;

temp = array[k];

for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)

{

array[j+gap] = array[j];

k = j;

}

array[k] = temp;

}

}while( gap > 1 );

}

int main()

{

int array[] = {21, 25, 49, 25, 16, 8};

int len = sizeof(array) / sizeof(*array);

println(array, len);

ShellSort(array, len);

println(array, len);

return 0;

}

2. 快速排序

（1）任取待排序序列中的某个数据元素（例如：第一个元素）作为基准，按照该元素的关键字大小整个序列划分为左右两个子序列：

l  左侧子序列中所有元素都小于或等于基准元素。

l  右侧子序列中所有元素都大于基准元素。

l  基准元素排在这两个子序列中间。

（2）分别对这两个子序列重复实施上述方法，直到所有的对象都排在相应的位置上为止。

首先对无序的记录序列进行“一次划分”，之后分别对分割所得两个子序列“递归”进行快速排序。

例题：

#include <stdio.h>

void println(int array[], int len)

{

int i = 0;

for(i=0; i<len; i++)

{

printf("%d ", array[i]);

}

printf("\n");

}

void swap(int array[], int i, int j)

{

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

int partition(int array[], int low, int high)

{

int pv = array[low];

while( low < high )

{

while( (low < high) && (array[high] >= pv) )

{

high--;

}

swap(array, low, high);

while( (low < high) && (array[low] <= pv) )

{

low++;

}

swap(array, low, high);

}

return low;

}

void QSort(int array[], int low, int high)

{

if( low < high )

{

int pivot = partition(array, low, high);

QSort(array, low, pivot-1);

QSort(array, pivot+1, high);

}

}

void QuickSort(int array[], int len) // O(n*logn)

{

QSort(array, 0, len-1);

}

int main()

{

int array[] = {21, 25, 49, 25, 16, 8};

int len = sizeof(array) / sizeof(*array);

println(array, len);

QuickSort(array, len);

println(array, len);

return 0;

}

上面的两种排列方式，虽然都很快，但是还是不稳定的，为了运算的稳定性，我们下面介绍归并排序。

3. 归并排序

(1)      将两个或两个以上的有序序列合并成一个新的有序数列：

(2)      有序序列V[1] …V[m]和V[m+1] …V[n]，变成V[1] …V[n]，这种归并方法称为2路归并。

(3)      将3个有序序列归并为一个新的有序列归并为一个新的有序列，称3路归并。

检测两个有序序列A和和B，C为归并后的新的有序序列：

当i和j都在两个序列内变化时,根据关键码的大小将较小的数据元素排放到新序列k所指位置中。

当i与j中有一个已经超出序列时，将另一个序列中的剩余部分照抄到新序列中。

例子：

#include <stdio.h>

#include <malloc.h>

void println(int array[], int len)

{

int i = 0;

for(i=0; i<len; i++)

{

printf("%d ", array[i]);

}

printf("\n");

}

void swap(int array[], int i, int j)

{

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

void Merge(int src[], int des[], int low, int mid, int high)

{

int i = low;

int j = mid + 1;

int k = low;

while( (i <= mid) && (j <= high) )

{

if( src[i] < src[j] )

{

des[k++] = src[i++];

}

else

{

des[k++] = src[j++];

}

}

while( i <= mid )

{

des[k++] = src[i++];

}

//这里的程序等价于

//des[k] = src[i];

//k++;   i++;

while( j <= high )

{

des[k++] = src[j++];

}

}

void MSort(int src[], int des[], int low, int high, int max)

{

if( low == high )

{

des[low] = src[low];

}

else

{

int mid = (low + high) / 2;

int* space = (int*)malloc(sizeof(int) * max);

if( space != NULL )

{

MSort(src, space, low, mid, max);

MSort(src, space, mid+1, high, max);

Merge(space, des, low, mid, high);

}

free(space);

}

}

void MergeSort(int array[], int len) // O(n*logn)

{

MSort(array, array, 0, len-1, len);

}

int main()

{

int array[] = {21, 25, 49, 25, 16, 8};

int len = sizeof(array) / sizeof(*array);

println(array, len);

MergeSort(array, len);

println(array, len);

return 0;

}

小结：

(1)      希尔排序，快速排序和归并排序将排序算法的时间复杂度提高到了O(n*logn)。

(2)      希尔排序和快速排序的排序结果是不稳定的。

(3)      归并排序的排序结果是稳定的。