-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删.
第一:
希尔排序
基本思想:
将待排序列划分为若干组 , 在每一组内进行插入排序 , 以使整个序列基本有序 , 然后再对整个序列进行插入排序
希尔排序的实现
#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)//插入排序算法,每次跳动为gap
{
k = i;
temp = array[k];
for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)//gap之前为有序序列,从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;
}
第二:
快速排序
基本思想:
1) 任取待排序序列中的某个数据元素( 例如 :第一个元素) 作为基准, , 按照该元素的关键字大小将整个序列划
分为左右两个子序列 :
? 左侧子序列中所有元素都小于或等于基准元素
? 右侧子序列中所有元素都大于基准元素
? 基准元素排在这两个子序列中间
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;
}
第三:
归并排序
基本思想: :
将两个或两个以上的有序序列合并成一个新的
有序序列 :
有序序列 V[1] … V[m] 和 V[ m +1] … V[n]
||
V[1] … V[n ]
这种归并方法称为2路归并。
归并排序的实现
#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++];
}
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;
}
小结
? 希尔排序 , 快速排序和归并排序将排序算法的时间复杂度提高到了 O(n* log n )
? 希尔排序和快速排序的排序结果是不稳定的
? 归并排序的排序结果是稳定的