void main()
{
int a[10]
int i,j,t
for(i=0i<=9i++)
scanf("%d",&a[i])
for(i=0i<9i++)
for(j=i+1j<10j++)
{
if(a[i]>a[j])
{ /*交换从这里开始*/
t=a[i]
a[i]=a[j]
a[j]=t}
} /*交换到这里结束*/
for(i=0i<=9i++)
printf("%d ",a[i])
printf("\n")/*下一次循环时换行*/
}
也没有多大的错误
小心点，C是分语句执行的，到了“；”就是一条语句，除非你用“{}”，这样可以将几个语句合并为一条语句。可以简单这么理解。
楼上的用的是C++若单纯的用C那就是这样
#include<stdio.h>
#define
"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=0i<10i++)
scanf("%d%d%d%d",&stu[i].num,&stu[i].mat,&stu[i].ENG,&stu[i].com)
for(i=0i<10i++)
{
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=0j<9j++)//冒泡排序
为理解简单
就没用别的排序方法
哈哈
{
for(i=0i<9-ji++)
{
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=0i<10i++)
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大学的
/*有一种排序方法叫Radix Sort,就是针对这种多关键字的排序的时间复杂度线性的，但是有个缺点就是必须知道关键字的范围，不知道题主的关键字范围是多少？
好吧，假设我的关键字最多有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=0i<ni++)
{
p=(Node*)malloc(sizeof(Node))
if(!p)
return
for(j=1j<=mj++)
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=0i<=ri++)
{
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=1i<=mi++)
printf("%d ",p->ele[i])
printf("\n")
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=0i<RADIXi++) //初始化首尾指针指向空指针
{
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("输入数据：\n")
init(head,n,m)
printf("输入基数范围0-n：")
scanf("%d",&r)
for(i=mi>=1i--)
distribute(head,i,r) //从低位到高位进行Radix排序
display(head,m)
for(i=0i<RADIXi++) //释放首尾指针数组
{
free(f[i])
free(e[i])
}
Delete(head)
free(head)
return 0
}
题主的答案：
更复杂的情况：
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）