排序算法c

① 排序算法性能比较（数据结构）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语言选择排序法和 冒泡排序法代码！

选择排序：

void select_sort(int a[],int n) //传入数组的要排序的元素个数

{int i,j,min,t;

for(i=0;i<n-1;i++)

{ min=i; //min:当前最小值下标

for(j=i+1;j<n;j++) //扫描余下的部分

if(a[min]>a[j]) //若有其它元素更小，就记录其下标

min=j;

if(min!=i) //保若最小值不在排序区首位，就换到首位

{t=a[min]; a[min]=a[i]; a[i]=t;}

}

}

冒泡排序：

void bubble_sort(int a[], int n) //传入数组的要排序的元素个数

{ int i, j, t;

for (j=0; j<n-1; j++) //n个元素比较n-1轮

for (i= 0; i<n-1-j;i++) //比较相信的两个数

if(a[i]>a[i+1]) //若大小顺序不符，就交换

{t=a[i]; a[i]=a[i+1]; a[i+1]=t;

}

③ 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语言，排序算法

对数组中的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
不知道对不对，我是这么认为的

⑤ c语言排序算法

#include<stdio.h>
#defineN100000//定义最多输入的数据
intsort(int*a,intn){
	inti,j,m;
	for(i=0;i<n-1;i++)
	for(j=i+1;j<n;j++)
		if(a[i]>a[j]){
			m=a[i];a[i]=a[j];a[j]=m;
		}
	return0;
}
intmain(){
	inta[N];
	inti=0,n,ii;
	while(1){
		//printf("输入n
");
		scanf("%d",&n);
		a[i++]=n;
		if(n==0)break;
		ii=i;
		for(;i<n+ii;i++)
			scanf("%d",&a[i]);
	}
	i=0;
	while(a[i]!=0){
		sort(a+i+1,a[i]);
		for(n=1;n<=a[i];n++)
			printf("%d",a[i+n]);
		printf("
");
		i=i+a[i]+1;
	}
}

⑥ C语言排序算法一共多少种

1. 选择排序
   

#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<stdio.h>#include<stdlib.h> #define TRUE 1#define FALSE 0#define OK 1#define ERROR#define OVERFLOW -2#define MAXSIZE 20 //一个用作示例的小顺序表的最大长度#define LT(a,b) ((a)<(b))#define LQ(a,b) ((a)<=(b)) typedef int KeyType;//定义关键字类型为整数类型typedef int InfoType;typedef struct{ KeyType key;//关键字项 InfoType otherinfo;//其他数据项}RedType;//记录类型typedef struct{ RedType r[MAXSIZE+1];//r[0]闲置或用作哨兵单元 int length;//顺序表长度}SqList;//顺序表类型 int InitList_Sq(SqList &L){//构造一个空的顺序表L。 int i; printf("请输入待排序的记录的个数："); scanf("%d",&L.length); printf("请输入待排序的记录的关键字（整型数）："); for(i=1;i<=L.length;i++) scanf("%d",&L.r[i]); return OK;} void Print_Sq(SqList &L) //输出{ int i; for(i=1;i<=L.length;i++) { printf("%4d",L.r[i]); } printf("\n");} //------------插入排序---void InsertSort(SqList &L){//对顺序表L作直接插入排序。 int i,j; for(i=2;i<=L.length;++i) if(LT(L.r[i].key,L.r[i-1].key))//“<”，需将L.r[i]插入有序子表 { L.r[0]=L.r[i];//复制为哨兵 L.r[i]=L.r[i-1]; for(j=i-2;LT(L.r[0].key,L.r[j].key);--j) L.r[j+1]=L.r[j];//记录后移 L.r[j+1]=L.r[0];//插入到正确位置 }}//--------------冒泡排序---void BubbleSort(SqList &L){//L.r是待排序的文件，采用自下向上扫描，对L.r做冒泡排序 int i,j; int exchange; // 交换标志 for(i=1;i<L.length;i++) {// 最多做 n-1 趟排序 exchange=FALSE; // 本趟排序开始前，交换标志应为假 for(j=L.length-1;j>=i;j--) // 对当前无序区 R[i..n] 自下向上扫描 if(LT(L.r[j+1].key,L.r[j].key)) { // 交换记录 L.r[0]=L.r[j+1]; //L.r[0]不是哨兵，仅做暂存单元 L.r[j+1]=L.r[j]; L.r[j]=L.r[0]; exchange=TRUE; // 发生了交换，故将交换标志置为真 } if(!exchange) // 本趟排序未发生交换，提前终止算法 return; } }//-----------快速排序---int Partition(SqList &L,int low,int high){//交换顺序表L中子表r[low..high]的记录，枢轴记录到位，并返回其所在位置，此时 //在它之前（后）的记录均不大（小）于它。 KeyType pivotkey; L.r[0]=L.r[low];//用子表的第一个记录作枢轴记录 pivotkey=L.r[low].key;//枢轴记录关键字 while(low<high) {//从表的两端交替地向中间扫描 while (low<high&&L.r[high].key>=pivotkey) --high; L.r[low]=L.r[high];//将比枢轴记录小的记录移到低端 while (low<high&&L.r[low].key<=pivotkey) ++low; L.r[high]=L.r[low];//将比枢轴记录大的记录移到高端 } L.r[low]=L.r[0];//枢轴记录到位 return low;//返回枢轴位置} void QSort(SqList &L,int low,int high){//对顺序表L中的子序列L.r[low..high]进行快速排序 int pivotloc; if(low<high) {//长度大于1 pivotloc=Partition(L,low,high);//将L.r[low..high]一分为二 QSort(L,low,pivotloc-1);//对低子表递归排序pivotloc是枢轴位置 QSort(L,pivotloc+1,high);//对高子表递归排序 }} void QuickSort(SqList &L){//对顺序表L作快速排序。 QSort(L,1,L.length);}//----------归并排序---void Merge(RedType SR[],RedType TR[],int i,int m,int n){//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] int j,k; for(j=m+1,k=i;i<=m&&j<=n;++k) {//将SR中记录由小到大地并入TR if LQ(SR[i].key,SR[j].key) TR[k]=SR[i++]; else TR[k]=SR[j++]; } if(i<=m)//TR[k..n]=SR[i..m];将剩余的SR[i..m]复制到TR while(k<=n&&i<=m) TR[k++]=SR[i++]; if(j<=n)//将剩余的SR[j..n]复制到TR while(k<=n&&j<=n) TR[k++]=SR[j++];} void MSort(RedType SR[],RedType TR1[],int s,int t){//将SR[s..t]归并排序为TR1[s..t]。 int m; RedType TR2[20]; if(s==t) TR1[t] = SR[s]; else { m=(s+t)/2;//将SR[s..t]平分为SR[s..m]和SR[m+1..t] MSort(SR,TR2,s,m);//递归地将SR[s..m]归并为有序的TR2[s..m] MSort(SR,TR2,m+1,t);//将SR[m+1..t]归并为有序的TR2[m+1..t] Merge(TR2,TR1,s,m,t);//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t] }} void MergeSort(SqList &L){// 对顺序表L作归并排序。 MSort(L.r, L.r, 1, L.length);}//-----------堆排序---void HeapAdjust(SqList &H,int s,int m){//已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义， //本函数调整H.r[s]的关键字，使H.r[s..m]成为一个大顶堆 //（对其中记录的关键字而言） int j; RedType rc; rc=H.r[s]; for(j=2*s;j<=m;j*=2) {//沿key较大的孩子结点向下筛选 if(j<m&&H.r[j].key<H.r[j+1].key) ++j;//j为key较大的记录的下标 if(rc.key>=H.r[j].key) break;//rc应插入在位置s上 H.r[s]=H.r[j]; s=j; } H.r[s]=rc;//插入} void HeapSort(SqList &H){//对顺序表H进行堆排序。 int i; RedType temp; for(i=H.length/2;i>0;--i)//把H.r[1..H.length]建成大顶堆 HeapAdjust(H,i,H.length); for(i=H.length;i>1;--i) { temp=H.r[i]; H.r[i]=H.r[1]; H.r[1]=temp;//将堆顶记录和当前未经排序子序列Hr[1..i]中 //最后一个记录相互交换 HeapAdjust(H,1,i-1);//将H.r[1..i-1]重新调整为大顶堆 }} void main(){ SqList S; printf("---------- 五种排序算法 ----------\n"); InitList_Sq(S); printf(" 1.简单插入排序\n"); InsertSort(S); Print_Sq(S); printf(" 2.冒泡排序\n"); BubbleSort(S); Print_Sq(S); printf(" 3.快速排序\n"); QuickSort(S); Print_Sq(S); printf(" 4.归并排序\n"); MergeSort(S); Print_Sq(S); printf(" 5.堆排序\n"); HeapSort(S); Print_Sq(S);}

⑧ C语言中的选择排序法是什么

选择排序（Selection sort）是一种简单直观的排序算法。工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

以下是一个实现选择排序的例子：

#defineSWAP(x,y,t)((t)=(x),(x)=(y),(y)=(t))
//将list中的n个数据，通过选择排序算法排序。
voidselete_sort(intlist[],intn)
{
inti,j,min,temp;
for(i=0;i<n-1;i++){
min=i;
for(j=i+1;j<n;j++)//找出最小元素的下标。
if(list[j]<list[min])
min=j;
SWAP(list[i],list[min],temp);//交换最小元素到当前起始位置。
}
}

⑨ c/c++排序算法的比较

快速排序是最快的，我曾经试过的，记得好像是o(n)。
另外两个在网络文库里找找吧，以前看过的，算法分析和代码都有