c语言排序算法比较
❶ c语言排序比较
#include<stdio.h>
#include<stdlib.h>
#include <math.h>
#define L 8 //排序元素个数
#define FALSE 0
#define TRUE 1
typedef struct
{
int key;
char otherinfo;
}RecType;
typedef RecType Seqlist[L+1];
int num; //定义排序趟数的全局变量
Seqlist R;
//直接插入排序
void Insertsort()
{
int i,j,k,m=0;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=2;i<=L;i++)
{
if(R[i].key<R[i-1].key)
{
R[0]=R[i];
j=i-1;
while(R[0].key<R[j].key)
{
R[j+1]=R[j];
j--;
}
R[j+1]=R[0];
}
m++;
printf("\t\t第%d趟排序结果为（按回车键继续）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//希尔排序
void Shellsort()
{
int i,j,gap,x,m=0,k;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
gap=L/2;
while(gap>0)
{
for(i=gap+1;i<=L;i++)
{
j=i-gap;
while(j>0)
{
if(R[j].key>R[j+gap].key)
{
x=R[j].key;
R[j].key=R[j+gap].key;
R[j+gap].key=x;
j=j-gap;
}
else
{
j=0;
}
}
}
gap=gap/2;
m++;
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//冒泡排序
void Bubblesort()
{
int i,j,k;
int exchange;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
exchange=FALSE;
for(j=L;j>=i+1;j--)
{
if(R[j].key<R[j-1].key)
{
R[0].key=R[j].key;
R[j].key=R[j-1].key;
R[j-1].key=R[0].key;
exchange=TRUE;
}
}
if(exchange)
{
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
int Partition(int i,int j) //i和j为形式参数，分别代表low和high
{
RecType pirot=R[i];
while(i<j)
{
while(i<j&&R[j].key>=pirot.key)
{
j--;
}
if(i<j)
{
R[i++]=R[j];
}
while(i<j&&R[j].key<=pirot.key)
{
i++;
}
if(i<j)
{
R[j--]=R[i];
}
}
R[i]=pirot;
return i;
}
//递归形式为快速排序
void Quicksort(int low,int high)
{
int pirotpos,k;
if(low<high)
{
pirotpos=Partition(low,high);
num++;
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",num);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
Quicksort(low,pirotpos-1);
Quicksort(pirotpos+1,high);
}
}
//选择排序
void Selectsort()
{
int i,j,k,h;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
h=i;
for(j=i+1;j<=L;j++)
{
if(R[j].key<R[h].key)
{
h=j;
}
}
if(h!=j)
{
R[0]=R[i];
R[i]=R[h];
R[h]=R[0];
}
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
void Merge(int low,int mm,int high)
{
int i=low,j=mm+1,p=0;
RecType *R1;
R1=new RecType[high-low+1];
if(!R1)
{
printf("内存容量不够！");
}
while(i<=mm&&j<=high)
{
R1[p++]=(R[i].key<=R[j].key)?R[i++]:R[j++];
}
while(i<=mm)
{
R1[p++]=R[i++];
}
while(j<=high)
{
R1[p++]=R[j++];
}
for(p=0,i=low;i<=high;p++,i++)
{
R[i]=R1[p];
}
}
void MergePass(int length)
{
int i;
for(i=1;i+2*length-1<=L;i=i+2*length)
{
Merge(i,i+length-1,i+2*length-1);
}
if(i+length-1<L)
{
Merge(i,i+length-1,L);
}
}
//归并排序
void Mergesort()
{
int length,k,m=0,i;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(length=1;length<L;length*=2)
{
MergePass(length);
m++;
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//堆建
void CreateHeap(int root,int index)
{
int j,temp,finish;
j=2*root;
temp=R[root].key;
finish=0;
while(j<=index&&finish==0)
{
if(j<index)
{
if(R[j].key<R[j+1].key)
{
j++;
}
}
if(temp>=R[j].key)
{
finish=1;
}
else
{
R[j/2].key=R[j].key;
j=j*2;
}
}
R[j/2].key=temp;
}//堆排序
void Heapsort()
{
int i,j,temp,k;
for(i=(L/2);i>=1;i--)
{
CreateHeap(i,L);
}
for(i=L-1,k=1;i>=1;i--,k++)
{
temp=R[i+1].key;
R[i+1].key=R[1].key;
R[1].key=temp;
CreateHeap(1,i);
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",k);
for(j=1;j<=L;j++)
{
printf("%5d",R[j].key);
}
getchar();
printf("\n");
}
}
void Heap()
{
int i;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
getchar();
printf("\n");
Heapsort();
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
main()
{
Seqlist S;
int i,k;
char ch1,ch2,q;
printf("\n\t\t请输入%d个待排序数据（按回车键分隔）：\n\t\t",L);
for(i=1;i<=L;i++)
{
scanf("%d",&S[i].key);
getchar();
printf("\t\t");
}
printf("\n\t\t排序数据已经输入完毕！");
ch1='y';
while(ch1=='y'||ch1=='Y')
{
printf("\n");
printf("\n\t\t 排 序 子 系 统 \n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t* 1--------更新排序数据 *\n");
printf("\n\t\t* 2--------直接插入排序 *\n");
printf("\n\t\t* 3--------希 尔 排 序 *\n");
printf("\n\t\t* 4--------冒 泡 排 序 *\n");
printf("\n\t\t* 5--------快 速 排 序 *\n");
printf("\n\t\t* 6--------选 择 排 序 *\n");
printf("\n\t\t* 7--------归 并 排 序 *\n");
printf("\n\t\t* 8--------堆 排 序 *\n");
printf("\n\t\t* 0--------返 回 *\n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t 请选择菜单号（0--8）：");
scanf("%c",&ch2);
getchar();
for(i=1;i<=L;i++)
{
R[i].key=S[i].key;
}
switch(ch2)
{
case '1':
printf("\n\t\t请输入%d个待排序数据（按回车键分隔）：\n\t\t",L);
for(i=1;i<=L;i++)
{
scanf("%d",&S[i].key);
getchar();
printf("\t\t");
}
printf("\n\t\t排序数据已经输入完毕！");
break;
case '2':
Insertsort();
break;
case '3':
Shellsort();
break;
case '4':
Bubblesort();
break;
case '5':
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
num=0;
Quicksort(1,L);
printf("\n\t\t排序的最终结果是：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
printf("\n");
break;
case '6':
Selectsort();
break;
case '7':
Mergesort();
break;
case '8':
Heap();
break;
case '0':
ch1='n';
break;
default:
system("cls");
printf("\n\t\t 对不起，您的输入有误，请重新输入！\n");
break;
}
if(ch2!='0')
{
if(ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8')
{
printf("\n\n\t\t排序输出完毕！");
printf("\n\t\t按回车键返回。");
q=getchar();
if(q!='\xA')
{
getchar();
ch1='n';
}
}
}
}
}
没有错啊！我刚才试了一下，没有错！你把工程命名的后缀名为.cpp就可以了。
❷ C语言编写代码实现几种内部排序算法的性能比较，有偿求代码和简要的实验报告。
http://wenku..com/view/6ff074740912a216147929db.html
可以参考这个
部分代码，使用了模板，其他算法自己弄把，输出的数据弄几个表格就是结果了
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
voidtestSort(intlen);
intmain(intargc,char*argv[])
{
testSort(10000);
testSort(20000);
testSort(40000);
testSort(80000);
testSort(160000);
testSort(320000);
testSort(640000);
testSort(1280000);
testSort(2560000);
testSort(5120000);
testSort(10240000);
return0;
}
#defineCOUNT_SETVAL//测试消耗时间注释掉这两句
#defineCOUNT_COMPARE
#ifdefCOUNT_SETVAL
__int64gSetValTimes;
#endif
#ifdefCOUNT_COMPARE
__int64gCompareTimes;
#endif
//交换
template<classT>
inlinevoidswap(T&_X,T&_Y)
{
T_T=_X;
_X=_Y;
_Y=_T;
#ifdefCOUNT_SWAP
gSwapTimes++;
#endif
#ifdefCOUNT_SETVAL
gSetValTimes+=3;
#endif
}
//复制
template<classT>
inlinevoidsetVal(T&_X,T&_Y)
{
_X=_Y;
#ifdefCOUNT_SETVAL
gSetValTimes++;
#endif
}
//比较
template<classT>
inlineintcompare(T&_X,T&_Y)
{
#ifdefCOUNT_COMPARE
gCompareTimes++;
#endif
return_X<_Y;
}
//堆排序
template<classT,classS>
voidheap_sort(T*_A,S_N)
{
Stop,bot,nxt,cur;
top=bot=nxt=_N;
while(cur=nxt,bot>0)
{
if(cur*2+1<bot&&compare(_A[nxt],_A[cur*2+1]))nxt=cur*2+1;
if(cur*2+2<bot&&compare(_A[nxt],_A[cur*2+2]))nxt=cur*2+2;
if(cur<nxt)swap(_A[cur],_A[nxt]);
elsenxt=top?--top:(swap(_A[0],_A[--bot]),0);
}
}
//原地合并排序
template<classT,classS>
voidncmerge_sort(T*_A,S_N)
{
Sstep,ins,l,m,r,pos0,pos1;
T*_T=newT[_N];
for(step=2;step<_N*2;step*=2)
{
for(l=0;l+step/2<_N;l+=step)
{
m=l+step/2;
r=m+step/2<_N?m+step/2:_N;
pos0=l;pos1=m;ins=0;
while(pos0<m&&pos1<r)
{
if(compare(_A[pos1],_A[pos0]))setVal(_T[ins++],_A[pos1++]);
elsesetVal(_T[ins++],_A[pos0++]);
}
while(pos0<m)setVal(_T[ins++],_A[pos0++]);
while(pos1<r)setVal(_T[ins++],_A[pos1++]);
while(ins>0)setVal(_A[--r],_T[--ins]);
}
}
delete[]_T;
}
//冒泡排序
template<classT,classS>
voidbubble_sort(T*_A,S_N)
{
Si,j,pos;
for(i=0;i<_N;i++)
{
pos=i;
for(j=i+1;j<_N;j++)if(compare(_A[j],_A[pos]))pos=j;
if(pos!=i)swap(_A[i],_A[pos]);
}
}
//快速排序
template<classT,classS>
voidquick_sort(T*_A,S_N)
{
Tpivot;
Sl=0;
Sm=_N/2;
Sr=_N-1;
if(_N>1)
{
if(compare(_A[r],_A[l]))swap(_A[l],_A[r]);
if(compare(_A[m],_A[l]))swap(_A[l],_A[m]);
if(compare(_A[r],_A[m]))swap(_A[m],_A[r]);
setVal(pivot,_A[m]);
while(l<=r)
{
while(compare(_A[l],pivot))l++;
while(compare(pivot,_A[r]))r--;
if(l<=r)swap(_A[l++],_A[r--]);
}
quick_sort(_A,r+1);
quick_sort(_A+l,_N-l);
}
return;
}
template<classT,classS>
voidheap2_sort(T*_A,S_N)
{
Ttempitem;
Scurrent,next;
Stop=_N/2;
while(_N>0)
{
if(top>0)top-=1;elseswap(_A[--_N],_A[0]);
setVal(tempitem,_A[top]);
current=top;
while(1)
{
next=current*2+1;
if(next+1<_N&&compare(_A[next],_A[next+1]))
{
next+=1;
}
if(next<_N)
{
setVal(_A[current],_A[next]);
current=next;
}
elsebreak;
}
while(next>0)
{
next=(current-1)/2;
if(next>=top&&compare(_A[next],tempitem))
{
setVal(_A[current],_A[next]);
current=next;
}
elsebreak;
}
setVal(_A[current],tempitem);
}
}
template<classT,classS>
voidcomb_sort(T*_A,S_N)
{
Snoswap=1;
Sdelta=_N;
Si;
while(!noswap||delta>1)
{
if(delta>1)
{
delta=(S)(delta/1.25);
}
for(noswap=1,i=0;i+delta<_N;i++)
{
if(compare(_A[i+delta],_A[i]))
{
noswap=0;
swap(_A[i+delta],_A[i]);
}
}
}
return;
}
voidtestSort(intlen)
{
srand(time(NULL));
int*Array=newint[len];
for(inti=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
clock_ttb=clock();
quick_sort(Array,len);
printf("quick:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
heap_sort(Array,len);
printf("heap:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
ncmerge_sort(Array,len);
printf("ncmerge:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
heap2_sort(Array,len);
printf("heap2:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
comb_sort(Array,len);
printf("comb:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
if(len<50000)
{
for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
bubble_sort(Array,len);
printf("bubble:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
}
printf(" ");
}
❸ C语言选择法排序
#include<stdio.h>
#defineM 5
void main()
{
int b[M],i,j,t,k;
for(i=0;i<M;i++)
scanf("%d",&b[i]);
for(i=0;i<M-1;i++)
{
for(k=i,j=i+1;j<M;j++)
if(b[k]<b[j])
k=j;
if(i!=k)
{
t=b[i];
b[i]=b[k];
b[k]=t;
}
}
for(i=0;i<M;i++)
printf("%d ",b[i]);
}
错在大括号位置加错了。
代码：
#include<stdio.h>
void SelectionSort(int *num,int n)
{
int i = 0;
int min = 0;
int j = 0;
int tmp = 0;
for(i = 0;i < n-1;i++)
{
min = i;//每次讲min置成无序组起始位置元素下标
for(j = i;j < n;j++)//遍历无序组，找到最小元素。
{
if(num[min]>num[j])
{
min = j;
}
}
if(min != i)//如果最小元素不是无序组起始位置元素，则与起始元素交换位置
{
tmp = num[min];
num[min] = num[i];
num[i] = tmp;
}
}
}
（此处空一行）
int main()
{
int num[6] = {5,4,3,2,9,1};
int i = 0;
SelectionSort(num,6);//这里需要将数列元素个数传入。有心者可用sizeof在函数内求得元素个数。
for(i = 0;i < 6;i++)
{
printf("%d ",num[i]);
}
return 0;
}
❹ C语言排序算法一共多少种
选择排序
#include<iostream>
usingnamespacestd;
voidselect_sort(intarr[],intnum);
voidoutput_array(intarr[],intnum);
intmain()
{
inta[10];
for(inti=0;i<10;i++)
{
cin>>a[i];
}
select_sort(a,10);
output_array(a,10);
return0;
}
voidselect_sort(intarray[],intn)//形参array是数组名
{
inti,j,k,t;
for(i=0;i<n-1;i++)
{
k=i;//先设第i个就为最小
for(j=i+1;j<n;j++)
if(array[j]<array[k])
k=j;//通过循环，得到k为最小
t=array[k];//交换a[i]和a[k]
array[k]=array[i];
array[i]=t;
}
return;
}
voidoutput_array(intarr[],intnum)
{
inti;
for(i=0;i<num;i++)
{
cout<<arr[i];
cout<<endl;
}
return;
}
2.冒泡排序
#include<stdio.h>
intmain()
{
inti,j,a[10],t;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(i=0;i<10;i++)
for(j=i+1;j<10;j++)
if(a[i]>a[j])
{
t=a[j];
a[j]=a[i];
a[i]=t;
}
for(i=0;i<10;i++)
printf("%d",a[i]);
return0;
}
3.堆排序
#include<iostream>
usingnamespacestd;
voidpaii(inta[20],inti,intm)
{
intk,t;
t=a[i];
k=2*i+1;
while(k<m)
{
if((k<m-1)&&(a[k]<a[k+1]))
k++;
if(t<a[k])
{
a[i]=a[k];
i=k;
k=2*i+1;
}
elsebreak;
}
a[i]=t;
}
voidipai(inta[20],intn)
{
inti,k;
for(i=n/2-1;i>=0;i--)
paii(a,i,n);
for(i=n-1;i>=1;i--)
{
k=a[0];
a[0]=a[i];
a[i]=k;
paii(a,0,i);
}}
intmain()
{
inta[10],i;
for(i=0;i<10;i++)
cin>>a[i];
ipai(a,10);
for(i=0;i<10;i++)
cout<<a[i]<<endl;
}
4.快速排序
#include<iostream>
usingnamespacestd;
voidQuicksort(inta[],intlow,inthigh)
{
if(low>=high)
{
return;
}
intfirst=low;
intlast=high;
intkey=a[first];
while(first<last)
{
while(first<last&&a[last]>=key)
--last;
a[first]=a[last];
while(first<last&&a[first]<=key)
++first;
a[last]=a[first];
}
a[first]=key;
Quicksort(a,low,first-1);
Quicksort(a,last+1,high);
}
intmain()
{
inti,a[100],x,n=0;
while(cin>>x)
{
a[n]=x;
n++;
}
n--;
Quicksort(a,0,n);
for(i=0;i<=n;i++)
cout<<a[i]<<"";
cout<<endl;
return0;
}
5. 基数排序
#include<stdio.h>
#include<stdlib.h>
intmain(){
intdata[10]={73,22,93,43,55,14,82,65,39,81};//对十个数进行排序
inttemp[10][10]={0};//构造一个临时二维数组，其值为0
intorder[10]={0};//构造一维数组，其值为0
inti,j,k,n,lsd;
k=0;n=1;
for(i=0;i<10;i++)printf("%d",data[i]);//在排序前，对这10个数打印一遍
putchar(' ');
while(n<=10){
for(i=0;i<10;i++){
lsd=((data[i]/n)%10);//lsd先对个位取余，然后再对十位取余，注意循环
temp[lsd][order[lsd]]=data[i];//temp[3][0]=73,temp[2][0]=22,temp[3][1]=93,temp[3][2]=43,⋯⋯
order[lsd]++;//需要区分的是lsd和order[lsd]，这两个不是一样的概念嗷
}
printf(" 重新排列:");
for(i=0;i<10;i++){
if(order[i]!=0)
for(j=0;j<order[i];j++){
data[k]=temp[i][j];
printf("%d",data[k]);
k++;
}
order[i]=0;
}
n*=10;//第二次用十位
k=0;
}
putchar(' ');
printf(" 排序后:");
for(i=0;i<10;i++)printf("%d",data[i]);
return0;
}
6.希尔排序
#include<iostream>
usingnamespacestd;
voidshell_sort(inta[],intn);
intmain()
{
intn,a[10000];
cin>>n;
for(inty=0;y<n;y++)
cin>>a[y];
shell_sort(a,n);
for(inti=0;i<n;i++)
cout<<a[i]<<"";
cout<<endl;
}
voidshell_sort(inta[],intn)
{
intgap,k,temp;//定义增量；
for(gap=3;gap>0;gap--)//设置初始增量，递减；
{
for(inti=0;i<gap;i++)//按增量分组；
{
for(intj=i+gap;j<n;j=j+gap)//每组分别比较大小；
{
if(a[j]<a[j-gap])
{
temp=a[j];
k=j-gap;
while(k>=0&&a[k]>temp)
{
a[k+gap]=a[k];
k=k-gap;
}
a[k+gap]=temp;
}
}
}
}
}
7.归并排序
#include<iostream>
usingnamespacestd;
voidMergeSort(intp[],ints,intm,intt)
{
intq[100];//q[100]用来存放排好的序列
inti=s;
intj=m+1;
intk=s;
while(i<=m&&j<=t)
{
if(p[i]<=p[j])
q[k++]=p[i++];
else
q[k++]=p[j++];
}
if(i<=m)
while(i<=m)
q[k++]=p[i++];
elsewhile(j<=t)
q[k++]=p[j++];
for(intn=s;n<=t;n++)
p[n]=q[n];
}
voidMerge(intp[],ints,intt)
{
if(s<t)
{
intm=(s+t)/2;//将数组分成两半
Merge(p,s,m);//递归拆分左数组
Merge(p,m+1,t);//递归拆分右数组
MergeSort(p,s,m,t);//合并数组
}
}
intmain()
{
intn;
intp[100];
cin>>n;
for(inti=0;i<n;i++)
cin>>p[i];
Merge(p,0,n-1);
for(intj=0;j<n;j++)
cout<<p[j]<<"";
cout<<endl;
return0;
}
排序方法基本就这些，还有双向冒泡这种拓展的排序方法，还有直接排序如桶排序
❺ 数据结构C语言——实现各种排序算法
刚做完的
#include <iostream>
using namespace std;
void BiInsertsort(int r[], int n) //插入排序（折半）
{
for(int i=2;i<=n;i++)
{
if (r[i]<r[i-1])
{
r[0] = r[i]; //设置哨兵
int low=1,high=i-1; //折半查找
while (low<=high)
{
int mid=(low+high)/2;
if (r[0]<r[mid]) high=mid-1;
else low = mid+1;
}
int j;
for (j=i-1;j>high;j--) r[j+1] = r[j]; //后移
r[j+1] = r[0];
}
}
for(int k=1;k<=n;k++) cout<<r[k]<<" ";
cout<<"\n";
}
void ShellSort ( int r[], int n) //希尔排序
{
for(int d=n/2;d>=1;d=d/2) //以d为增量进行直接插入排序
{
for (int i=d+1;i<=n;i++)
{
r[0] = r[i]; //暂存被插入记录
int j;
for( j=i-d; j>0 && r[0]<r[j]; j=j-d) r[j+d] = r[j]; //记录后移d个位置
r[j+d] = r[0];
}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}
void BubbleSort(int r[], int n) //起泡排序
{
int temp,exchange,bound;
exchange=n; //第一趟起泡排序的范围是r[0]到r[n-1]
while (exchange) //仅当上一趟排序有记录交换才进行本趟排序
{
bound=exchange;
exchange=0;
for (int j=1; j<bound; j++) //一趟起泡排序
if (r[j]>r[j+1])
{
temp=r[j];
r[j]=r[j+1];
r[j+1]=temp;
exchange=j; //记录每一次发生记录交换的位置
}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}
int Partition(int r[], int first, int end) //快速排序一次划分
{
int i=first; //初始化
int j=end;
r[0]=r[first];
while (i<j)
{
while (i<j && r[0]<= r[j]) j--; //右侧扫描
r[i]=r[j];
while (i<j && r[i]<= r[0]) i++; //左侧扫描
r[j]=r[i];
}
r[i]=r[0];
return i; //i为轴值记录的最终位置
}
void QuickSort(int r[], int first, int end) //快速排序
{
if (first<end)
{ //递归结束
int pivot=Partition(r, first, end); //一次划分
QuickSort(r, first, pivot-1);//递归地对左侧子序列进行快速排序
QuickSort(r, pivot+1, end); //递归地对右侧子序列进行快速排序
}
}
void SelectSort(int r[ ], int n) //简单选择排序
{
int i,j,index,temp;
for (i=1; i<n; i++) //对n个记录进行n-1趟简单选择排序
{
index=i;
for (j=i+1; j<=n; j++) //在无序区中选取最小记录
if (r[j]<r[index]) index=j;
if (index!=i)
{
temp=r[i];
r[i]=r[index];
r[index]=temp;
}
}
for(i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}
void main()
{
const int numv=12;
int a[3][numv]={{0,6,13,19,23,37,39,41,45,48,58,86},{0,86,58,48,45,41,39,37,23,19,13,6},{0,23,13,48,86,19,6,41,58,37,45,39}};
int z1[numv],z2[numv];
int m,n;
cout<<"请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]" <<endl;
cin>>m;
while(m>0&&m<4)
{
cout<<"请选择排序算法：⑴直接插入排序 ⑵希尔排序 ⑶冒泡排序 ⑷快速排序 \n ⑸简单选择排序"<<endl;
cin>>n;
switch(n)
{
case 1:
cout << "直接插入排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n直接插入排序结果为：" << "\n";
BiInsertsort(a[m-1],numv-1);
break;
case 2:
cout << "\n希尔排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n希尔排序结果为：" << "\n";
ShellSort(a[m-1], numv-1);
break;
case 3:
cout << "\n冒泡排序前：" << "\n";
for(int k=1;k<numv;k++) cout<<a[m-1][k]<<" ";
cout << "\n冒泡排序结果为：" << "\n";
BubbleSort(a[m-1], numv-1);
break;
case 4:
cout << "\n快速排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n快速排序结果为：" << "\n";
QuickSort(a[m-1],0,numv-1);
for(int i=1;i<numv;i++)
cout<<a[m-1][i]<<" ";
cout<<"\n";
break;
case 5:
cout << "\n简单选择排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n简单选择排序结果为：" << "\n";
SelectSort(a[m-1],numv-1);
break;
default:
cout<<"输入错误！"<<endl;
}
m=0;
cout<<"请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]" <<endl;
cin>>m;
}
if(m==4) cout<<"(*^__^*) 再见！"<<endl;
else cout<<"输入错误！"<<endl;
}
❻ 谁帮我写一份c语言版的各种排序算法的效率比较
（1）“冒泡法” 冒泡法大家都较熟悉。其原理为从a[0]开始，依次将其和后面的元素比较,若a[0]>a[i]，则交换它们，一直比较到a[n]。同理对a[1],a[2],...a[n-1]处理，即完成排序。下面列出其代码：void bubble(int *a,int n) /*定义两个参数：数组首地址与数组大小*/ { int i,j,temp; for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) /*注意循环的上下限*/ if(a[i]>a[j]) { temp=a[i]; a[i]=a[j]; a[j]=temp; } } 冒泡法原理简单，但其缺点是交换次数多，效率低。 下面介绍一种源自冒泡法但更有效率的方法“选择法”。 （2）“选择法” 选择法循环过程与冒泡法一致，它还定义了记号k=i,然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.最后看看k=i是否还成立，不成立则交换a[k],a[i],这样就比冒泡法省下许多无用的交换，提高了效率。void choise(int *a,int n) { int i,j,k,temp; for(i=0;i<n-1;i++) { k=i; /*给记号赋值*/ for(j=i+1;j<n;j++) if(a[k]>a[j]) k=j; /*是k总是指向最小元素*/ if(i!=k) { /*当k!=i是才交换，否则a[i]即为最小*/ temp=a[i]; a[i]=a[k]; a[k]=temp; } } } 选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。 （3）“快速法” 快速法定义了三个参数，（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j). 它首先选一个数组元素（一般为a[(i+j)/2],即中间元素）作为参照，把比它小的元素放到它的左边，比它大的放在右边。然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。下面分析其代码：void quick(int *a,int i,int j) { int m,n,temp; int k; m=i; n=j; k=a[(i+j)/2]; /*选取的参照*/ do { while(a[m]<k&&m<j) m++; /* 从左到右找比k大的元素*/ while(a[n]>k&&n>i) n--; /* 从右到左找比k小的元素*/ if(m<=n) { /*若找到且满足条件，则交换*/ temp=a[m]; a[m]=a[n]; a[n]=temp; m++; n--; } }while(m<=n); if(m<j) quick(a,m,j); /*运用递归*/ if(n>i) quick(a,i,n); } （4）“插入法” 插入法是一种比较直观的排序方法。它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。把数组元素插完也就完成了排序。void insert(int *a,int n) { int i,j,temp; for(i=1;i<n;i++) { temp=a[i]; /*temp为要插入的元素*/ j=i-1; while(j>=0&&temp<a[j]) { /*从a[i-1]开始找比a[i]小的数，同时把数组元素向后移*/ a[j+1]=a[j]; j--; } a[j+1]=temp; /*插入*/ } } （5）“shell法” shell法是一个叫 shell 的美国人与1969年发明的。它首先把相距k(k>=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。下面让我们来分析其代码：void shell(int *a,int n) { int i,j,k,x; k=n/2; /*间距值*/ while(k>=1) { for(i=k;i<n;i++) { x=a[i]; j=i-k; while(j>=0&&x<a[j]) { a[j+k]=a[j]; j-=k; } a[j+k]=x; } k/=2; /*缩小间距值*/ } } 上面我们已经对几种排序法作了介绍，现在让我们写个主函数检验一下。 #include<stdio.h> /*别偷懒，下面的"..."代表函数体，自己加上去哦！*/ void bubble(int *a,int n) { ... } void choise(int *a,int n) { ... } void quick(int *a,int i,int j) { ... } void insert(int *a,int n) { ... } void shell(int *a,int n) { ... } /*为了打印方便，我们写一个print吧。*/[code]void print(int *a,int n) { int i; for(i=0;i<n;i++) printf("%5d",a[i]); printf("\n"); } main() { /*为了公平，我们给每个函数定义一个相同数组*/ int a1[]={13,0,5,8,1,7,21,50,9,2}; int a2[]={13,0,5,8,1,7,21,50,9,2}; int a3[]={13,0,5,8,1,7,21,50,9,2}; int a4[]={13,0,5,8,1,7,21,50,9,2}; int a5[]={13,0,5,8,1,7,21,50,9,2}; printf("the original list:"); print(a1,10); printf("according to bubble:"); bubble(a1,10); print(a1,10); printf("according to choise:"); choise(a2,10); print(a2,10); printf("according to quick:"); quick(a3,0,9); print(a3,10); printf("according to insert:"); insert(a4,10); print(a4,10); printf("according to shell:"); shell(a5,10); print(a5,10); }
❼ C语言各种排序算法比较次数和运行时间的计算，改如何写，算法我已经写好了。
1. 比较次数，你加个变量比较一次统计一下不就可以了。
2. 统计运行时间
time_tbeg=clock();
InsertSort(...);
time_tend=clock();
printf("%lf ",(end-beg)/CLOCKS_PER_SEC);
应该是要加头文件<time.h>
❽ 排序算法性能比较（数据结构）C语言程序
这题你只要把每个算法的程序代码看一下，在计算下就行
冒泡排序：两个循环，从1加到N，(1+N)N/2
=
500500,最坏交换情况是每次判断都要交换，既500500*3次
选择排序：也是两个循环，比较次数跟冒泡排序一样500500，但是这个只要底层循环交换，既只需1000*3
=
3000次赋值。
插入排序：循环次数一样500500，但是这个最坏情况是每比较一次就赋值一次，既需500500次赋值
希尔排序：时间复杂度是N^1.3倍，比较次数和赋值应该是1000^1.3次方。
归并排序和快速排序，你去查查它的时间复杂度是怎么算，O(lgN*N),好像有系数，算法导论那本书上有，现在不记得是多少了。
希望能帮到你，
❾ c语言排序算法
对每一个国家名字字符串按字典序排序，从头开始，比较每一个字母的大小，比如：
abc,
abd,
aaa,
bac，aaaa，5个国家，排序后
aaa,
aaaa,
abc,
abd,
bac
❿ C语言，排序算法
对数组中的10个元数前几个进行排序，安从小到大的顺序。设n=5
如：10个元数是1，9，8，7，5
i=1时。temp=v[1]=9；j=0 v[j]=v[0]=1；不符合循环条件，不做；
i=2时。temp=v[2]=8；j=1 v[j]=v[1]=9；符合循环条件，做循环体；
v[1]=8；v[2]=9；这时数组为1，8，9，7，5
i=3时。temp=v[3]=7，j=2 v[j]=v[2]=9；符号循环条件。做循环体
v[1]=7,v[2]=8,v[3]=9。数组为1，7，8，9，5。
i=4时。做法是一样的
最后结果为1，5，7，8，9
不知道对不对，我是这么认为的