排序演算法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)。
另外兩個在網路文庫里找找吧，以前看過的，演算法分析和代碼都有