几种经典排序.docx
《几种经典排序.docx》由会员分享，可在线阅读，更多相关《几种经典排序.docx（14页珍藏版）》请在冰豆网上搜索。
几种经典排序
2.堆排序
冒泡排序：
快速排序：
简单选择排序：
设所排序序列的记录个数为ｎ。
i取1,2,…,n-1,从所有n-i+1个记录（R,Ri+1,…,Rn中找出排序码最小的记录，与第ｉ个记录交换。
执行n-1趟后就完成了记录序列的排序。
基数排序：
（radixsort）则是属于“分配式排序”（distributionsort），基数排序法又称“桶子法”（bucketsort）或binsort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O（nlog（r）m），其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。
假设原来有一串数值如下所示：
73,22,93,43,55,14,28,65,39,81
首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：
0
181
222
3739343
414
55565
6
7
828
939
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
81,22,73,93,43,14,55,65,28,39
接着再进行一次分配，这次是根据十位数来分配：
0
114
22228
339
443
555
665
773
881
993
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
14,22,28,39,43,55,65,73,81,93
这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。
插入排序：
归并排序：
归并操作（merge），也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。
如 设有数列{6，202，100，301，38，8，1}
初始状态：
[6][202][100][301][38][8][1]比较次数
i=1[6202][100301][838][1] 3
i=2[6100202301][1838] 4
i=3 [16838100202301]4
总计：
11次
堆排序：
#include"stdafx.h"
#include"iostream"
usingnamespacestd;
//所有排序均按从小到大
//显示数组
voidDisplay（inta[],intn）
{
inti;
for（i=1;i<=n;i++）
{
cout<}
cout<}
//交换元素
voidswap（int&a,int&b）
{
inttemp;
temp=a;
a=b;
b=temp;
}
//冒泡排序
voidBubbleSort（inta[],intn）
{
inti,j;
cout<<"冒泡排序过程：
"<for（i=1;i<=n;i++）
{
boolexchange=false;
for（j=1;j<=n-i;j++）
if（a[j]>a[j+1]）
{//交换记录
swap（a[j],a[j+1]）;
exchange=true;
}
Display（a,10）;
if（!
exchange）//exchange若为假说明数组已排序成功
return;
}
cout<}
//简单排序
voidSelectSort（inta[],intn）
{
inti,j;
cout<<"简单排序过程：
"<for（i=1;i<=n-1;i++）
{
for（j=i+1;j<=n;j++）
{
if（a[j]{
swap（a[i],a[j]）;
}
}
Display（a,10）;
}
cout<}
//直接插入排序
//在start位开始到end位结束的数组向后移一位，插入数据data
voidMoveStep（inta[],intstart,intend,intdata）
{
inti;
for（i=end;i>=start;i--）
{
a[i+1]=a[i];
}
a[start]=data;
}
voidSimpleInsertSort（inta[],intn）
{
inti,j;
cout<<"简单排序过程：
"<for（i=2;i<=n;i++）
{
for（j=1;j<=i-1;j++）
{
if（a[i]{
//插入
MoveStep（a,j,i-1,a[i]）;
}
}
Display（a,10）;
}
cout<}
//基数排序
voidBucketSort（inta[],intn）
{
intm[10][10];
inti,j,k;
//m[i][0]存放桶中个数
cout<<"基数排序过程：
"<for（i=0;i<=9;i++）
{
m[i][0]=0;
}
for（i=1;i<=n;i++）
{
j=a[i]%10;
m[j][0]=m[j][0]+1;//桶中个数加
m[j][m[j][0]]=a[i];
}
//个数位整理数组
k=1;
for（i=0;i{
for（j=1;j<=m[i][0];j++）
{
a[k++]=m[i][j];
}
}
Display（a,10）;
//m[i][0]存放桶中个数清零
for（i=0;i<=9;i++）
{
m[i][0]=0;
}
//十位数整理数组
for（i=1;i<=n;i++）
{
j=a[i]/10;
m[j][0]=m[j][0]+1;//桶中个数加
m[j][m[j][0]]=a[i];
}
k=1;
for（i=0;i{
for（j=1;j<=m[i][0];j++）
{
a[k++]=m[i][j];
}
}
Display（a,10）;
}
//归并排序
voidMerge（intA[],intlow,intmid,inthigh）
{
inti=low;
intj=mid+1;
int*T;
T=（int*）malloc（sizeof（int）*（high））;
intk=0;
while（i<=mid&&j<=high）
{
if（A[i]<=A[j]）
{
T[k++]=A[i++];
}
else
{
T[k++]=A[j++];
}
}
if（i==mid+1）
{
while（j<=high）
{
T[k++]=A[j++];
}
}
else
{
while（i<=mid）
{
T[k++]=A[i++];
}
}
for（i=low,k=0;i<=high;i++,k++）
A[i]=T[k];
free（T）;
}
voidMergeSort（inta[],intlow,inthigh）
{
intmid=0;
if（low{
mid=（low+high）/2;
MergeSort（a,low,mid）;
MergeSort（a,mid+1,high）;
Merge（a,low,mid,high）;
}
}
//快速排序
voidQuickSort（inta[],intlow,inthigh）
{
intj,index;
if（low>=high）
return;
swap（a[low],a[（low+high）/2]）;
index=low;
cout<<"快速排序过程：
"<for（j=low+1;j<=high;j++）
{
if（a[j]swap（a[++index],a[j]）;
Display（a,10）;
}
swap（a[low],a[index]）;
QuickSort（a,low,index-1）;
QuickSort（a,index+1,high）;
}
//希尔排序
voidMoveStep（inta[],intstart,intend,intdata,intstep）
{
inti;
for（i=end;i>=start;i=i-step）
{
a[i+step]=a[i];
}
a[start]=data;
//MoveStep（a,i,j-dk,a[j],dk）;
}
voidShellSort（inta[],intn）
{
int*step,k,i,t,dk,j;
k=n;
step=（int*）malloc（sizeof（int）*（n/2））;
i=0;
do
{
k=k/2;
step[i++]=k;
}while（k>0）;
i=0;
while（dk=step[i++]>0）
{
for（i=1;i<=n;i++）
{
for（j=i+dk;j<=n;j=j+dk）
{
for（k=i;k<=（j-dk）;k=k+dk）
if（a[k]>a[j]）
{
//插入
MoveStep（a,k,j-dk,a[j],dk）;
}
}
}
}
}
//堆排序
voidmain（）
{
inta[11]={-1,22,1,54,47,9,10,3,2,12,6};
inti;
cout<<"原数据:
"<Display（a,10）;
cout<//BubbleSort（a,10）;
//cout<"<//Display（a,10）;
//SelectSort（a,10）;
//cout<"<//Display
升级会员 