排序如何編程

⑴ C語言需要四個數從小到大排序怎麼編程

#
include
<stdio.h>void
main
(){
int
t,a,b,c,d; printf("請輸入4個數；");
scanf（"%d,%d,%d,%d",&a，&b，&c，&d）;
printf（"a=%d,b=%d,c=%d,d=%d\n",a,b,c,d）;
if(a>b)
{t=a;a=b;b=t;} if(a>b)
{t=a;a=b;b=t;}}
if(a>c)
{t=a;a=c;c=t;}
if(a>d)
{t=a;a=d;d=t;}
if(b>c)
{t=b;b=c;c=t;}
if(b>d)
{t=b;b=d;d=t;}
if(c>d)
{t=c;c=d;d=t;}
printf("排序結果如下：\n");
printf("%d
%d
%d
%d
\n",a,b,c,d);
C語言即中文版的C語言，是一種面向過程的計算機程序設計語言。

⑵ 如何用C語言編寫一個排序程序

樓上的用的是C++
若單純的用C那就是這樣
#include<stdio.h>
#define
print
"NO.%d
%d
%d
%d
%d
%3.2f
%3.2f\n",1+i,stu[i].num,stu[i].mat,stu[i].ENG,stu[i].com,stu[i].aver,stu[i].total//宏定義節約時間
struct
student
{
int
num;
int
mat;
int
ENG;
int
com;
float
aver;
float
total;
}stu[10];//定義結構體變數
void
main()
{
int
i;
void
take_turn_print(struct
student
stu1[10])
;
float
sum(int
x,int
y,int
z);//聲明求和函數
for(i=0;i<10;i++)
scanf("%d%d%d%d",&stu[i].num,&stu[i].mat,&stu[i].ENG,&stu[i].com);
for(i=0;i<10;i++)
{
stu[i].total=sum(stu[i].mat,stu[i].ENG,stu[i].com);//調用求和函數
stu[i].aver=stu[i].total/3;
}
take_turn_print(stu);//調用排序
列印函數
}
void
take_turn_print(struct
student
stu1[10])
{
void
change(int
*x,int
*y);//聲明換位函數
void
change1(float
*x,float
*y);//聲明換位函數
int
i,j;
for(j=0;j<9;j++)//冒泡排序
為理解簡單
就沒用別的排序方法
哈哈
{
for(i=0;i<9-j;i++)
{
if(stu1[i].aver<stu1[i+1].aver)
{
change(&stu1[i].num,&stu1[i+1].num);//
值交換
change(&stu1[i].mat,&stu1[i+1].mat);//
值交換
change(&stu1[i].ENG,&stu1[i+1].ENG);//
值交換
change(&stu1[i].com,&stu1[i+1].com);//
值交換
change1(&stu1[i].aver,&stu1[i+1].aver);//
值交換
change1(&stu1[i].total,&stu1[i+1].total);//
值交換
}
}
}
for(i=0;i<10;i++)
printf(print);//列印
}
void
change(int
*x,int
*y)
{
int
i;
i=*x;
*x=*y;
*y=i;//利用指針做變數替換
}
void
change1(float
*x,float
*y)
{
float
i;
i=*x;
*x=*y;
*y=i;//利用指針做變數替換
}
float
sum(int
x,int
y,int
z)
{
float
i;
i=(float)(x+y+z);
return(i);
}
前幾天也是幫同學做這樣的題
一模一樣
看來你也是WH大學的

⑶ C語言編程:選擇法排序

選擇排序是一種簡單直觀的排序演算法。

工作原理：

每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。

性能：

選擇排序是不穩定的排序方法（比如序列[5， 5， 3]第一次就將第一個[5]與[3]交換，導致第一個5挪動到第二個5後面）。

選擇排序的時間復雜度是O(n^2)

思想：

n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：

①初始狀態：無序區為R[1..n]，有序區為空。

②第1趟排序

在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。

……

③第i趟排序

第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(i..n）。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。

C語言版代碼：

#include<stdio.h>
#include<math.h>

#defineMAX_SIZE101
#defineSWAP(x,y,t)((t)=(x),(x)=(y),(y)=(t))

voidsort(int[],int);/*selectionsort*/

intmain()
{
inti,n;
intlist[MAX_SIZE];
printf(":");
scanf_s("%d",&n);
if(n<1||n>MAX_SIZE){
fprintf(stderr,"Impropervalueofn
");
exit(1);
}
for(i=0;i<n;i++){/*randomlygeneratenumbers*/
list[i]=rand()*1000;
printf("%d",list[i]);
}
sort(list,n);
printf("
Sortedarray:
");
for(i=0;i<n;i++)/*printoutsortednumbers*/
printf("%d",list[i]);
printf("
");
return0;
}
voidsort(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語言編程 排序

/*有一種排序方法叫RadixSort,就是針對這種多關鍵字的排序的
時間復雜度線性的，但是有個缺點就是必須知道關鍵字的范圍，不知道題主的關鍵字范圍是多少？

好吧，假設我的關鍵字最多有100個，基數最大不超過999
程序如下：*/

//Radix Sort演算法，採取LSD（低位優先）

#include<stdio.h>

#include<stdlib.h>

#define KEYNUM 100 //關鍵字的最大個數

#define RADIX 1000 //基數的范圍是0-RADIX-1

typedef struct Node

{

int ele[KEYNUM+1];

struct Node *next;

} Node;

Node *e[RADIX],*f[RADIX]; //鏈隊列的首指針和尾指針表

void init(Node* head,int n,int m) //初始化輸入鏈表

{

int i,j;

Node *p,*q=head;

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

{

p=(Node*)malloc(sizeof(Node));

if(!p)

return;

for(j=1; j<=m; j++)

scanf("%d",&p->ele[j]);

p->next=NULL;

q->next=p;

q=q->next;

}

}

void distribute(Node* head,int locate,int r) //進行Radix排序

{

Node *p,*q;

int i;

while(head->next!=NULL)

{

q=head->next;

head->next=q->next;

q->next=NULL;

p=f[q->ele[locate]];

while(p->next!=NULL)

p=p->next;

p->next=q;

e[q->ele[locate]]->next=q;

}

p=head;

for(i=0; i<=r; i++)

{

while(f[i]->next!=e[i]->next)

{

q=f[i]->next;

f[i]->next=q->next;

q->next=NULL;

p->next=q;

p=p->next;

}

q=f[i]->next;

if(q)

{

f[i]->next=q->next;

q->next=NULL;

p->next=q;

p=p->next;

}

f[i]->next=e[i]->next=NULL;

}

}

void display(Node* head,int m) //顯示鏈表各個節點

{

int i;

Node* p=head->next;

if(!head)

return;

while(p)

{

for(i=1; i<=m; i++)

printf("%d ",p->ele[i]);

printf(" ");

p=p->next;

}

}

void Delete(Node* head) //釋放鏈表節點

{

Node *p;

if(!head)

return;

while(head->next)

{

p=head->next;

head->next=p->next;

free(p);

}

}

int main()

{

Node* head;

int n,m,r,i;

for(i=0; i<RADIX; i++) //初始化首尾指針指向空指針

{

f[i]=(Node*)malloc(sizeof(Node));

e[i]=(Node*)malloc(sizeof(Node));

if(!f[i]||!e[i])

exit(1);

f[i]->next=e[i]->next=NULL;

}

head=(Node*)malloc(sizeof(Node));

if(!head)

return 1;

printf("待排序個數以及關鍵字的個數：");

scanf("%d%d",&n,&m);

printf("輸入數據： ");

init(head,n,m);

printf("輸入基數范圍0-n：");

scanf("%d",&r);

for(i=m; i>=1; i--)

distribute(head,i,r); //從低位到高位進行Radix排序

display(head,m);

for(i=0; i<RADIX; i++) //釋放首尾指針數組

{

free(f[i]);

free(e[i]);

}

Delete(head);

free(head);

return 0;

}

題主的答案：

⑹ C語言數組排序方法

選擇排序的原理是，每次從待排序數字中挑選出最大（最小）數字，放在有序序列的末尾。實際操作中，只需要在這個數組中將挑出來的數字與前面的數字交換即可。例如：4
1 5
2 3找到最小的1，1和4交換1
4 5
2
3找到最小的2，2和4交換1
2
5
4
3找到最小的3，3和5交換1
2
3
4
5找到最小的4，4和4交換（不交換也可）可見，選擇排序需要一個雙重循環來完成，因此它的復雜度是O(n^2)在數據量比較大時，不建議使用這種排序方法。 其他排序方法有很多，你甚至可以自己根據不同數據規模設計不同的排序方法。比較常見的有冒泡排序，插入排序（這兩種和選擇排序一樣，都是O(n^2)），二分法插入排序（降低了一些復雜度，但是涉及到大規模數據移動，效率依然不高），快速排序（平均復雜度O(nlogn)，但是不穩定，最壞情況O(n^2)），隨機化快速排序（很大程度上避免了最壞情況的出現），堆排序（O(nlogn)，編程復雜度高），基數排序（理論復雜度O(n)，實際要比這個慢。甚至能應付字元串排序，但是編程復雜度高，牽扯到其他數據結構），桶排序（O(n)，編程簡單，效率高，但是應付的數據范圍不能太大，受到內存大小的限制）。 平時比較常用的就是快速排序，程序簡單，效率也可以接受。 這是我了解的一些東西，希望對你有幫助。

⑺ 誰能幫我詳細解答下編程里的幾種排序方法。

詳解： http://ke..com/w?ct=17&lm=0&tn=WikiSearch&pn=0&rn=10&word=%C5%C5%D0%F2&submit=search歸並排序 歸並排序歸並排序是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法(Divide and Conquer)的一個非常典型的應用。歸並(Merge)排序法是將兩個(或兩個以上)有序表合並成一個新的有序表,即把待排序序列分為若干個子序列,每個子序列是... 5千字 2008-7-24 coolxiaojiB 快速排序 概述快速排序(Quick Sort)是一種有效的排序演算法。雖然演算法在最壞的情況下運行時間為O(n^2),但由於平均運行時間為O(nlogn),並且在內存使用、程序實現復雜性上表現優秀,尤其是對快速排序演算法進行隨機化的可能,使得快速排序在一般情況下是最實用... 8千字 2008-7-29 追月一族2 堆排序 斯坦福大學計算機科學系教授羅伯特·弗洛伊德(Robert W.Floyd)和威廉姆斯(J.Williams)在1964年共同發明了著名的堆排序演算法( Heap Sort ) 定義n個關鍵字序列Kl,K2,…,Kn稱為(Heap),當且僅當該序列滿足如下性質(簡稱為堆性質): (1... 10千字 2008-7-14 Watfourane 冒泡排序 冒泡排序:BubbleSort基本概念冒泡排序的基本概念是:依次比較相鄰的兩個數,將大數放在前面,小數放在後面。即首先比較第1個和第2個數,將大數放前,小數放後。然後比較第2個數和第3個數,將大數放前,小數放後,如此繼續,直至比較最後兩... 3千字 2008-4-12 凜冬將至_ 排序演算法 所謂排序,就是使一串記錄,按照其中的某個或某些關鍵字的大小,遞增或遞減的排列起來的操作。分類在計算機科學所使用的排序演算法通常被分類為: 計算的復雜度(最差、平均、和最好表現),依據串列(list)的大小(n)。一般而言,好的表現... 5千字 2008-3-18 12月26日魔羯座 希爾排序 希爾排序(Shell Sort)是插入排序的一種。因D.L.Shell於1959年提出而得名。希爾排序基本思想基本思想:先取一個小於n的整數d1作為第一個增量,把文件的全部記錄分成d1個組。所有距離為dl的倍數的記錄放在同一個組中。先在各組內進行直... 2千字 2008-1-15 WXD11011 基數排序 「基數排序法」(radix sort)則是屬於「分配式排序」(distribution sort),基數排序法又稱「桶子法」(bucket sort)或bin sort,顧名思義,它是透過鍵值的部份資訊,將要排序的元素分配至某些「桶」中,藉以達到排序的作用,基數排序法是屬於穩定性... 2千字 2007-12-23 gotolabel Shell排序 希爾排序是一種快速排序法,它出自D.L.Shell,因此而得名。Shell排序又稱作縮小增量排序。基本思想:不斷把待排序的對象分成若干個小組,對同一小組內的對象採用直接插入法排序,當完成了所有對象都分在一個組內的排序後,排序過程結束。... 1千字 2006-10-14 raoping2005 選擇排序 基本思想 每一趟從待排序的數據元素中選出最小(或最大)的一個元素,順序放在已排好序的數列的最後,直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法。排序過程 【示例】: 初始關鍵字 [49 38 65 97 76 13 27 49]第一...

⑻ 用C語言編程實現快速排序演算法

給個快速排序你參考參考

/**********************快速排序****************************
基本思想：在待排序的n個記錄中任取一個記錄（通常取第一個記錄），
		以該記錄為基準，將當前的無序區劃分為左右兩個較小的無
		序子區，使左邊的記錄均小於基準值，右邊的記錄均大於或
		等於基準值，基準值位於兩個無序區的中間位置（即該記錄
		最終的排序位置）。之後，分別對兩個無序區進行上述的劃
		分過程，直到無序區所有記錄都排序完畢。
*************************************************************/

/*************************************************************
函數名稱：staticvoidswap(int*a,int*b)
參數：int*a---整型指針
		int*b---整型指針
功能：交換兩個整數的位置
返回值：無
說明：static關鍵字指明了該函數只能在本文件中使用
**************************************************************/
staticvoidswap(int*a,int*b)
{
inttemp=*a;
*a=*b;
*b=temp;
}

intquickSortNum=0;//快速排序演算法所需的趟數
/*************************************************************
函數名稱：staticintpartition(inta[],intlow,inthigh)
參數：inta[]---待排序的數據
		intlow---無序區的下限值
		inthigh---無序區的上限值
功能：完成一趟快速排序
返回值：基準值的最終排序位置
說明：static關鍵字指明了該函數只能在本文件中使用
**************************************************************/
staticintpartition(inta[],intlow,inthigh)
{
intprivotKey=a[low];//基準元素
while(low<high)
	{//從表的兩端交替地向中間掃描
while(low<high&&a[high]>=privotKey)//找到第一個小於privotKey的值
			high--;//從high所指位置向前搜索，至多到low+1位置
swap(&a[low],&a[high]);//將比基準元素小的交換到低端

while(low<high&&a[low]<=privotKey)//找到第一個大於privotKey的值
			low++;//從low所指位置向後搜索，至多到high-1位置
swap(&a[low],&a[high]);//將比基準元素大的交換到高端
}
	quickSortNum++;//快速排序趟數加1
	returnlow;//返回基準值所在的位置
}

/*************************************************************
函數名稱：voidQuickSort(inta[],intlow,inthigh)
參數：inta[]---待排序的數據
		intlow---無序區的下限值
		inthigh---無序區的上限值
功能：完成快速排序演算法，並將排序完成的數據存放在數組a中
返回值：無
說明：使用遞歸方式完成
**************************************************************/
voidQuickSort(inta[],intlow,inthigh)
{
if(low<high)
	{
intprivotLoc=partition(a,low,high);//將表一分為二
QuickSort(a,low,privotLoc-1);//遞歸對低子表遞歸排序
QuickSort(a,privotLoc+1,high);//遞歸對高子表遞歸排序
}	
}

⑼ 簡單編程（排序）

應該用插入排序，完整的程序如下：

{$apptypeconsole}
{
http://..com/question/52392340.html?si=3
期末考試後，老師請你幫忙統計年級所有同學的總分和名次，同時附加了一個要求，希望能盡可能早的知道前十名。
}
programexp;
type
TStudent=record
num:integer;{學號}
name:string;{姓名}
s1,s2,s3,s4,ss:integer;{語文、數學、政治、外語、總分}
end;
var
i,j,StudentCount:integer;
Student:TStudent;
Students:array[1..100]ofTStudent;
begin
{初始化}
StudentCount:=0;
{輸入數據，並同時排序}
repeat
write('學號(負數結束輸入)？');readln(Student.num);
ifStudent.num>0then
begin
write('姓名?');readln(Student.name);
write('語文、數學、政治、外語：');withStudentdoreadln(s1,s2,s3,s4);
withStudentdoss:=s1+s2+s3+s4;
{查找第一個總分小於新輸入學生的j}
j:=1;
while(j<=StudentCount)and(Students[j].ss>=Student.ss)doj:=j+1;
{把j及以後的學生往後移動}
ifj<=StudentCountthen
fori:=StudentCount+1downtojdoStudents[i]:=Students[i-1];
StudentCount:=StudentCount+1;
{新數據插入到位置j}
Students[j]:=Student;
{顯示前十名}
write('總分前十名：');
fori:=1toStudentCountdo
ifi<=10then
withStudents[i]do
write(name,'(',ss,')');
writeln;
end;
untilStudent.num<=0;
{輸出結果}
writeln('名次學號姓名語文數學政治外語總分');
fori:=1toStudentCountdo
withStudents[i]do
writeln(i:6,num:6,name:6,s1:6,s2:6,s3:6,s4:6,ss:6);
end.

以上程序在DELPHI下調試通過，運行情況示例如下：
E:\ygb>dcc32a.dpr
BorlandDelphiVersion15.0
Copyright(c)1983,
a.dpr(51)
52lines,0.05seconds,13832bytescode,4649bytesdata.

E:\ygb>a.exe
學號(負數結束輸入)？1
姓名?111
語文、數學、政治、外語：10203040
總分前十名：111(100)
學號(負數結束輸入)？2
姓名?222
語文、數學、政治、外語：10101010
總分前十名：111(100)222(40)
學號(負數結束輸入)？3
姓名?333
語文、數學、政治、外語：10201010
總分前十名：111(100)333(50)222(40)
學號(負數結束輸入)？4
姓名?444
語文、數學、政治、外語：20304050
總分前十名：444(140)111(100)333(50)222(40)
學號(負數結束輸入)？0
名次學號姓名語文數學政治外語總分
1444420304050140
2111110203040100
333331020101050
422221010101040

⑽ 用C語言編寫一個快速排序演算法 輸入10個數

1、「快速排序法」使用的是遞歸原理，下面一個例子來說明「快速排序法」的原理。首先給出一個數組{53，12，98，63，18，72，80，46， 32，21}，先找到第一個數--53，把它作為中間值，也就是說，要把53放在一個位置，使得它左邊的值比它小，右邊的值比它大。{21，12，32， 46，18，53，80，72，63，98}，這樣一個數組的排序就變成了兩個小數組的排序--53左邊的數組和53右邊的數組，而這兩個數組繼續用同樣的方式繼續下去，一直到順序完全正確。一般來說，冒泡法是程序員最先接觸的排序方法，它的優點是原理簡單，編程實現容易，但它的缺點就是速度太慢。
2、快速排序代碼：

#include<stdio.h>
voidquicksort(inta[],intleft,intright)
{
inti,j,temp;
i=left;
j=right;
temp=a[left];
if(left>right)
return;
while(i!=j)
{
while(a[j]>=temp&&j>i)
j--;
if(j>i)
a[i++]=a[j];
while(a[i]<=temp&&j>i)
i++;
if(j>i)
a[j--]=a[i];

}
a[i]=temp;
quicksort(a,left,i-1);
quicksort(a,i+1,right);
}
voidmain()
{
inta[]={53,12,98,63,18,72,80,46,32,21};
inti;
quicksort(a,0,9);
/*排好序的結果*/
for(i=0;i<10;i++)
printf("%4d
",a[i]);
}