结构体，链表的建造及输出函数如下，求一个对链表按学号升序排列的函数。
#include
#include
#define NULL 0
#define LEN sizeof(struct student)
struct stude
结构体，链表的建造及输出函数如下，求一个对链表按学号升序排列的函数。
#include
#include
#define NULL 0
#define LEN sizeof(struct student)
struct student
{
char name[20];
struct student *
};
struct student *creat(void)/*建造*/
{
struct student*
struct student *p1,*p2;
p1=p2=(struct student *)malloc(LEN);
scanf("%ld,%s",&p1->num,p1->name);
head=NULL;
while(p1->num!=0)
if(n==1)head=p1;
else p2->next=p1;
p1=(struct student*)malloc(LEN);
scanf("%ld,%s",&p1->num,p1->name);
p2->next=NULL;
return(head);
}
void print(struct student *head)/*输出*/
{
struct student *p;
printf("\nNOW.These%d records are:\n",n);
if(head!=NULL)
printf("%ld,%s\n",p->num,p->name);
while(p!=NULL);
}
==========================
功能：选择排序(由小到大)
返回：指向链表表头的指针
==========================
*/
选择排序的基本思想就是反复从还未排好序的那些节点中，
选出键值（就是用它排序的字段，我们取学号num为键值）最小的节点，
依次重新组合成一个链表。
我认为写链表这类相关信息，关键是理解：
head存储的是第一个节点的地址，head->next存储的是第二个节点的地址；
任意一个节点p的地址，只能通过它前一个节点的next来求得。
单向链表的选择排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head
---->[NULL]（空链表）
first
tail
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
first
tail->nex...
==========================
功能：选择排序(由小到大)
返回：指向链表表头的指针
==========================
*/
选择排序的基本思想就是反复从还未排好序的那些节点中，
选出键值（就是用它排序的字段，我们取学号num为键值）最小的节点，
依次重新组合成一个链表。
我认为写链表这类相关信息，关键是理解：
head存储的是第一个节点的地址，head->next存储的是第二个节点的地址；
任意一个节点p的地址，只能通过它前一个节点的next来求得。
单向链表的选择排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head
---->[NULL]（空链表）
first
tail
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
first
tail->next
图10：有N个节点的链表选择排序
1、先在原链表中找最小的，找到一个后就把它放到另一个空的链表中；
2、空链表中安放第一个进来的节点，产生一个有序链表,并且让它在原链表中分离出来（此时要注意原链表中出来的是第一个节点还是中间其它节点）；
3、继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针；
*/
struct student *SelectSort(struct student *head)
{
struct student * /*排列后有序链的表头指针*/
struct student * /*排列后有序链的表尾指针*/
struct student *p_ /*保留键值更小的节点的前驱节点的指针*/
struct student * /*存储最小节点*/
struct student *p; /*当前比较的节点*/
first = NULL;
while (head != NULL) /*在链表中找键值最小的节点。*/
/*注意：这里for语句就是体现选择排序思想的地方*/
for (p=head,min= p->next!=NULL; p=p->next) /*循环遍历链表中的节点，找出此时最小的节点。*/
if (p->next->num num) /*找到一个比当前min小的节点。*/
p_min = /*保存找到节点的前驱节点：显然p->next的前驱节点是p。*/
min = p-> /*保存键值更小的节点。*/
/*上面for语句结束后，就要做两件事；一是把它放入有序链表中；二是根据相应的条件判断，安排它离开原来的链表。*/
/*第一件事*/
if (first == NULL) /*如果有序链表目前还是一个空链表*/
first = /*第一次找到键值最小的节点。*/
tail = /*注意：尾指针让它指向最后的一个节点。*/
else /*有序链表中已经有节点*/
tail->next = /*把刚找到的最小节点放到最后，即让尾指针的next指向它。*/
tail = /*尾指针也要指向它。*/
/*第二件事*/
if (min == head) /*如果找到的最小节点就是第一个节点*/
head = head-> /*显然让head指向原head->next,即第二个节点，就OK*/
else /*如果不是第一个节点*/
p_min->next = min-> /*前次最小节点的next指向当前min的next,这样就让min离开了原链表。*/
if (first != NULL) /*循环结束得到有序链表first*/
tail->next = NULL; /*单向链表的最后一个节点的next应该指向NULL*/
/*
==========================
功能：直接插入排序(由小到大)
返回：指向链表表头的指针
==========================
*/
直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值
（就是用它排序的字段，我们取学号num为键值）排好序的，对于节点n在
这个序列中找插入位置，使得n插入后新序列仍然有序。按照这种思想，依次
对链表从头到尾执行一遍，就可以使无序链表变为有序链表。
单向链表的直接插入排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head
---->[1]---->[NULL]（从原链表中取第1个节点作为只有一个节点的有序链表）
head
图11
---->[3]---->[2]...---->[n]---->[NULL]（原链表剩下用于直接插入排序的节点）
first
n->next
图12
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
head
图13：有N个节点的链表直接插入排序
1、先在原链表中以第一个节点为一个有序链表，其余节点为待定节点。
2、从图12链表中取节点，到图11链表中定位插入。
3、上面图示虽说画了两条链表，其实只有一条链表。在排序中，实质只增加了一个用于指向剩下需要排序节点的头指针first罢了。
这一点请读者务必搞清楚，要不然就可能认为它和上面的选择排序法一样了。
*/
struct student *InsertSort(struct student *head)
{
struct student * /*为原链表剩下用于直接插入排序的节点头指针*/
struct student *t; /*临时指针变量：插入节点*/
struct student *p; /*临时指针变量*/
struct student *q; /*临时指针变量*/
first = head-> /*原链表剩下用于直接插入排序的节点链表：可根据图12来理解。*/
head->next = NULL; /*只含有一个节点的链表的有序链表：可根据图11来理解。*/
while (first != NULL) /*遍历剩下无序的链表*/
/*注意：这里for语句就是体现直接插入排序思想的地方*/
for (t=first, q= ((q!=NULL) && (q->num num)); p=q, q=q->next); /*无序节点在有序链表中找插入的位置*/
/*退出for循环，就是找到了插入的位置*/
/*注意：按道理来说，这句话可以放到下面注释了的那个位置也应该对的，但是就是不能。原因：你若理解了上面的第3条，就知道了。*/
first = first-> /*无序链表中的节点离开，以便它插入到有序链表中。*/
if (q == head) /*插在第一个节点之前*/
else /*p是q的前驱*/
t->next = /*完成插入动作*/
/*first = first->*/
/*
==========================
功能：冒泡排序(由小到大)
返回：指向链表表头的指针
==========================
*/
直接插入排序的基本思想就是对当前还未排好序的范围内的全部节点，
自上而下对相邻的两个节点依次进行比较和调整，让键值（就是用它排
序的字段，我们取学号num为键值）较大的节点往下沉，键值较小的往
上冒。即：每当两相邻的节点比较后发现它们的排序与排序要求相反时，
就将它们互换。
单向链表的冒泡排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
head
图14：有N个节点的链表冒泡排序
任意两个相邻节点p、q位置互换图示:
假设p1->next指向p，那么显然p1->next->next就指向q,
p1->next->next->next就指向q的后继节点，我们用p2保存
p1->next->next指针。即：p2=p1->next->next，则有：
[
]---->[p]---------->[q]---->[
]（排序前）
p1->next->next
p2->next
图15
]---->[q]---------->[p]---->[
]（排序后）
1、排序后q节点指向p节点，在调整指向之前，我们要保存原p的指向节点地址，即：p2=p1->next->next；
2、顺着这一步一步往下推,排序后图16中p1->next->next要指的是p2->next,所以p1->next->next=p2->
3、在图15中p2->next原是q发出来的指向，排序后图16中q的指向要变为指向p的，而原来p1->next是指向p的，所以p2->next=p1->
4、在图15中p1->next原是指向p的，排序后图16中p1->next要指向q,原来p1->next->next（即p2)是指向q的，所以p1->next=p2;
5、至此，我们完成了相邻两节点的顺序交换。
6、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置，这样我们不必每次都从头到尾的扫描，只需要扫描到记录点为止。
因为后面的都已经是排好序的了。
*/
struct student *BubbleSort(struct student *head)
{
struct student * /*控制循环比较*/
struct student *p; /*临时指针变量*/
struct student *p1;
struct student *p2;
p1 = (struct student *)malloc(LEN);
p1->next = /*注意理解：我们增加一个节点，放在第一个节点的前面，主要是为了便于比较。因为第一个节点没有前驱，我们不能交换地址。*/
head = p1; /*让head指向p1节点，排序完成后，我们再把p1节点释放掉*/
for (endpt=NULL; endpt!= endpt=p) /*结合第6点理解*/
for (p=p1= p1->next->next!= p1=p1->next)
if (p1->next->num > p1->next->next->num) /*如果前面的节点键值比后面节点的键值大，则交换*/
p2 = p1->next-> /*结合第1点理解*/
p1->next->next = p2-> /*结合第2点理解*/
p2->next = p1-> /*结合第3点理解*/
p1->next = p2; /*结合第4点理解*/
p = p1->next-> /*结合第6点理解*/
p1 = /*把p1的信息去掉*/
head = head-> /*让head指向排序后的第一个节点*/
free(p1); /*释放p1*/
p1 = NULL; /*p1置为NULL，保证不产生“野指针”，即地址不确定的指针变量*/
/*
==========================
功能：插入有序链表的某个节点的后面(从小到大)
返回：指向链表表头的指针
==========================
*/
/*
有序链表插入节点示意图：
---->[NULL]（空有序链表）
head
图18：空有序链表（空有序链表好解决，直接让head指向它就是了。）
以下讨论不为空的有序链表。
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（有序链表）
head
图18：有N个节点的有序链表
插入node节点的位置有两种情况：一是第一个节点前，二是其它节点前或后。
---->[node]---->[1]---->[2]---->[3]...---->[n]---->[NULL]
head
node->next
图19：node节点插在第一个节点前
---->[1]---->[2]---->[3]...---->[node]...---->[n]---->[NULL]
head
node->next
图20：node节点插在其它节点后
*/
struct student *SortInsert(struct student *head, struct student *node)
{
struct student *p; /*p保存当前需要检查的节点的地址*/
struct student *t; /*临时指针变量*/
if (head == NULL) /*处理空的有序链表*/
node->next = NULL;
n += 1; /*插入完毕，节点总数加1*/
p = /*有序链表不为空*/
while (p->num num && p != NULL) /*p指向的节点的学号比插入节点的学号小，并且它不等于NULL*/
t = /*保存当前节点的前驱，以便后面判断后处理*/
p = p-> /*后移一个节点*/
if (p == head)
/*刚好插入第一个节点之前*/
node->next =
else /*插入其它节点之后*/
t->next = /*把node节点加进去*/
node->next =
n += 1; /*插入完毕，节点总数加1*/
测试代码如下：
/*测试SelectSort():请编译时去掉注释块*/
head = SelectSort(head);
Print(head);
/*测试InsertSort():请编译时去掉注释块*/
head = InsertSort(head);
Print(head);
/*测试BubbleSort():请编译时去掉注释块*/
head = BubbleSort(head);
Print(head);
/*测试SortInsert():上面创建链表，输入节点时请注意学号num从小到大的顺序。请编译时去掉注释块*/
stu = (struct student *)malloc(LEN);
printf("/nPlease input insert node -- num,score: ");
scanf("%ld,%f",&stu->num,&stu->score);
head = SortInsert(head,stu);
free(stu);
stu = NULL;
Print(head);
其他答案（共2个回答）
#includetypedef strct Lnode{//学号；　//姓名／／年龄／／学号L...
c语言链表排序游标的作用，就是类似一个指针。在信息工程中指针是一个用来指示一个内存地址的计算机语言的变量或中央处理器(CPU)中寄存器(Register)【用来...
定义全局的链表长度，在有些函数中长度动态变化没有关系。此外可以设计链表的头结点为非数据节点，里面存在链表长度。对于排序，可以写个void sort(List L...
保存链表的话至少需要注意两点:1). 尽量不要保存指针域, 其他的都可以保存, 从文件读取时重新动态创建链表, 从文件恢复除指针域以外的其他域, 如果为了简单保...
答: laguna的预定网站上显示要1/15以后才能预定吗?
答: cisco网络技术是一个为CTO、IT技术经理、网络工程师、安全工程师、数据库工程师、网络管理员、系统工程师、开发工程师、项目管理人员等IT技术人员搭建的有关先...
答: 我想学网页制作、网络维护、电脑维护可有比较好的学习网站或者论坛推选一下？你好！网易学院
大家还关注
确定举报此问题
举报原因(必选)：
广告或垃圾信息
激进时政或意识形态话题
不雅词句或人身攻击
侵犯他人隐私
其它违法和不良信息
报告，这不是个问题
报告原因(必选)：
这不是个问题
这个问题分类似乎错了
这个不是我熟悉的地区
相关问答：123456789101112131415用结构体数组存储30名学生的学号，姓名，性别，和成绩。按平均成绩输出报表。（较清晰版）
# include "stdio.h"
# define N 30
struct fengshu
struct xinxi
& char name[15];
average(int a, int b, int c, int d)
& int sum=0;
& sum=a+b+c+d;
& ave=sum/4.0;
& return(ave);
& int i,j;
& struct xinxi s[N];
& for(i=0;i
printf("请输入第%d个同学的信息:\n",i+1);
printf("姓名:");
gets(s[i].name);&&&&&&
&&&&printf("语文，数学，英语和C语言的成绩（中间用空格分开）
&&& scanf("%d %d
%d",&s[i].score.chinese,&s[i].score.math,&s[i].score.english,&s[i].score.Clanguage);
getchar();&&&&&&&&&&&&
& for(i=0;i
s[i].ave=average(s[i].score.chinese,s[i].score.math,s[i].score.english,s[i].score.Clanguage);
& for(i=0;i&N;i++)
for(j=i+1;j&N;j++)
if(s[i].ave&s[j].ave)
&&&&&&&&&&
&&&&&&&&&&
s[i]=s[j];
&&&&&&&&&&
&& printf("按平均分排序为:\n");
for(i=0;i&N;i++)
printf("学号:%d& 姓名:%s&
性别:%c& 语文,数学,英语,C语言成绩:%d %d %d
%d&& 平均成绩:%d&
\n",s[i].num,s[i].name,s[i].sex,s[i].score.chinese,s[i].score.math,s[i].score.english,s[i].score.Clanguage,s[i].ave);
}&&&&&&&&&&&&&&&&&
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。22:45 提问
用结构体数组存储某班的30名学生的信息，每个学生的数据项有学号
用结构体数组存储某班的30名学生的信息，每个学生的数据项有学号、姓名、性别和四门课的成绩。编写程序计算四门课的平均成绩，要求用键盘输入学生数据，再按平均成绩排序，并输出含平均成绩的报表。
按赞数排序
其他相关推荐
其他相似问题