排序如何编程

⑴ 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]);
}