第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(" ");
}
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(" ");
}
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(" ");
}
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) 归并排序的排序结果是稳定的。