经典的几种排序方式
所谓排序就是整理文件中的记录，使之按关键字递增（或递减）次序排列起来。
稳定排序与不稳定排序：
假设 Ki = Kj ，且排序前序列中 Ri 领先于 Rj ；
若在排序后的序列中 Ri 仍领先于 Rj ，则称排序方法是稳定的。
若在排序后的序列中 Rj 仍领先于 Ri ，则称排序方法是不稳定的。
例：序列 3 15 8 8 6 9
若排序后得 3 6 8 8 9 15 稳定的#两个8 不同顺序
若排序后得 3 6 8 8 9 15 不稳定的
根据排序过程中待排序记录是否全部放置在内存中，排序分为内排和外排。
内部排序: 指的是待排序记录存放在计算机随机存储器中进行的排序过程。
外部排序: 指的是待排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中尚需对外存进行访问的排序过程。
算法的复杂性：体现在运行该算法时的计算机所需资源的多少上，计算机资源最重要的是时间和空间（即寄存器）资源，因此复杂度分为时间和空间复杂度。
辅助空间：辅助空间是评价排序算法的一个重要指标，辅助空间是指除了存放待排序资源之外，执行算法所需要的其他存储空间。
时间复杂度：简单的说就是程序循环执行的总的次数。算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。时间复杂度常用大O符号表述，即O(f(n))。
按照排序过程中所依据的原则的不同可以分类为:
►插入排序
直接插入排序 希尔排序
►交换排序
冒泡排序 快速排序
►选择排序
简单选择排序 堆排序
►归并排序
►基数排序
介绍几种已经掌握的排序方法：
直接插入排序：
对于给定的一组记录，初始时假定第一个记录自成一个有序的序列，其余的记录为无序序列；接着从第二个记录开始，按照记录的大小依次将当前处理的记录插入到其之前的有序序列中，直至最后一个记录插入到有序序列为止。
例：将 29 18 87 56 3 27 按由小到大排序
① (29) (18 87 56 3 27)
② (18 29) (87 56 3 27)
③ (18 29 87) (56 3 27)
④ (18 29 56 87) (3 27)
⑤ ( 3 18 29 56 87) (27)
⑥ (3 18 27 29 56 87)
具体的程序看下：（由于头文件写了不好上传 请用时自行加上 下面也是）
int main()
{
int i,j,temp,length;
int a[5] = {8, 7, 3, 5, 1};
length = sizeof(a)/sizeof(a[0]);
for(i = 1; i < length; i++)
{
temp = a[i];
for(j = i-1 ;j >= 0; j–)
{
if(temp < a[j])
{
a[j+1]= a[j];
}
else
{
break;
}
}
a[j+1] = temp;
}
for(i = 0; i < length; i++)
{
printf("%d",a[i]);
}
printf("\n");
return 0;
}
稳 定 性：稳定
时间复杂度： O(n^2)
(1)初始数据正序，总比较次数：n-1
(2)初始数据逆序，总比较次数：(n2+n-1)/2= O(n2)
(3)初始数据无序，第i趟平均比较次数(i+1)/2，总次数为：(n2+3n)/4=O(n2)
(4)可见，原始数据越趋向正序，比较次数和移动次数越少。
希尔排序：
希尔排序也称为“缩小增量排序”，基本原理是：首先将待排序的元素分为多个子序列，使得每个子序的元素个数相对较少，对各个子序分别进行直接插入排序，待整个待排序序列“基本有序后”，再对所有元素进行一次直接插入排序。
希尔排序的特点：
时间复杂度：希尔排序的时间复杂性在O（nlog2n）和O（n2 ）之间，大致为O（n1.3）。
稳 定 性：不稳定
具体程序如下：
int main()
{
int a[] = {2,5,7,25,89,105,34};
int length,i,j,temp,gap;
length = sizeof(a)/ sizeof(a[0]);
for(gap = length/2; gap > 0; gap /= 2)
{
for(i = gap; i < length; i++ )
{
temp = a[i];
for(j = i - gap; j >= 0 && temp < a[j];j=j-gap)
{
a[j+gap] = a[j];
}
a[j+gap]= temp;
}
}
for(i = 0; i < length; i++)
{
printf(“%d “,a[i]);
}
printf(“\n”);
return 0;
}
快速排序：
快速排序是一种非常高效的排序方法，采用“分而治之”的思想，把大的拆分为小的，小的在拆分为更小的。
原理是：对于一组给定的记录，通过一趟排序后，将原序列分为两部分，其中前部分的所有记录均比后部分的所有记录小，然后再依次对前后两部分的记录进行快速排序，递归该过程，直到序列中的所有记录均为有序为止
快速排序特点：
稳 定 性：不稳定
平均时间复杂度： O(nlog2n)
程序如下：
void Sort(int *a,int low,int high)
{
int i,j;
int index;
i = low;
j = high;
index = a[i];
if(low >= high)
{
return;
}
while(i < j)
{
while(i < j && a[j] >= index)
{
j--;
}
if(i < j)
{
a[i++] = a[j];
}
while(i < j && a[i] < index)
{
i++;
}
if(i < j)
{
a[j--] = a[i];
}
}
a[i] = index;
Sort(a,low,i - 1);
Sort(a,i + 1,high);
}
void QuickSort(int a[], int length)
{
Sort(a,0,length - 1);
}
int main()
{
int a[] = {9, 8, 15, 78, 54, 89, 21, 36};
int i;
int length = sizeof(a) /sizeof(a[0]);
QuickSort(a,length);
for(i = 0; i < length; i++)
{
printf(“%d “,a[i]);
}
printf(“\n”);
return 0;
}
归并排序：
利用递归与分治技术将数据序列划分为越来越小的半子表，再对半子表排序，最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列。
原理如下：对于给定的一组记录，首先将两个相邻的长度为1的子序列进行归并，得到n/2个长度为2或者1的有序子序列，在将其两两归并，反复执行此过程，直到得到一个有序的序列为止。
例：将49 38 65 97 76 13 27由小到大排序
初始化关键字:[49] [38] [65] [97] [76] [13] [27]
一趟归并后： [38 49] [65 97] [13 76] [27]
二趟归并后： [38 49 65 97] [13 27 76]
三趟归并后： [13 27 38 49 65 76 97]
归并排序特点：
平均时间复杂度： O(nlog2n)
稳 定 性： 稳定
程序如下：
void merging(int a[],int begin,int mid,int end)
{
int tmp = (int )malloc(sizeof(int)*(end - begin + 1));
int i,j,k;
i = begin;
j = mid + 1;
k = 0;
while(i <= mid && j <=end)
{
if(a[i] < a[j])
tmp[k++] = a[i++];
else
tmp[k++] = a[j++];
}
while(i <= mid)
tmp[k++] = a[i++];
while(j <= end)
tmp[k++] = a[j++];
for(i = 0;i < k;i++)
{
a[begin + i] = tmp[i];
}
free(tmp);
}
void merge_sort(int a[],int begin,int end)
{
int mid;
if(a == NULL || begin >= end)
return;
mid = (begin + end) / 2;
merge_sort(a,begin,mid);
merge_sort(a,mid + 1,end);
merging(a,begin,mid,end);
}
int main()
{
int i,length;
int a[10] = {0};
printf(“enter 10 num…\n”);
for(i = 0;i < 10;i++)
{
scanf(“%d”,&a[i]);
}
length = sizeof(a)/sizeof(int);
merge_sort(a,0,length - 1);
for(i = 0;i < length;i++)
{
printf("%d ",a[i]);
}
return 0;
}