c语言程序
发布时间:2025-05-15 04:38:43 发布人:远客网络
一、c语言程序
#define LEN sizeof(struct scorenode)
typedef struct scorenode score;
int n,k;/*n,k为全局变量，本程序中的函数均可以使用它*/
/*==============================================================================================*/
/*函数creat2311,功能：创建链表，此函数带回一个指向链表头的指针*/
p1=p2=p3=(score*)malloc(LEN);head=p3;/*开辟一个新单元*/
printf("请输入学生资料，输0退出!\n");
repeat1: printf("请输入学生学号(学号应大于0)：");/*输入学号，学号应大于0*/
printf("输入错误，请重新输入学生学号:");
/*输入学号为字符或小于0时，程序报错，提示重新输入学号*/
goto end;/*当输入的学号为0时，转到末尾，结束创建链表*/
{if(p1->number!=p3->number)
{printf("学号重复,请重输!\n");
/*当输入的学号已经存在，程序报错，返回前面重新输入*/
scanf("%s",&p1->name);/*输入学生姓名*/
printf("请输入c成绩(0~100)：");/*输入c成绩，成绩应在0-100*/
while(p1->cyuyan<0||p1->cyuyan>100)
printf("输入错误，请重新输入c成绩");/*输入错误，重新输入c成绩直到正确为止*/
printf("请输入vb成绩(0~100)：");/*输入vb成绩，成绩应在0-100*/
while(p1->vbyuyan<0||p1->vbyuyan>100)
printf("输入错误，请重新输入vb成绩");/*输入错误，重新输入vb成绩直到正确为止*/
scanf("%f",&p1->vbyuyan);}
printf("请输入sql成绩(0~100)：");/*输入sql成绩，成绩应在0-100*/
scanf("%f",&p1->sqlyuyan);
while(p1->sqlyuyan<0||p1->sqlyuyan>100)
printf("输入错误，请重新输入sql成绩");
scanf("%f",&p1->sqlyuyan);}/*输入错误，重新输入sql成绩直到正确为止*/
printf("请输入学生资料，输0退出!\n");
repeat2:printf("请输入学生学号(学号应大于0)：");
scanf("%d",&p1->number);/*输入学号，学号应大于0*/
printf("输入错误,请重新输入学生学号:");
/*输入学号为字符或小于0时，程序报错，提示重新输入学号*/
goto end;/*当输入的学号为0时，转到末尾，结束创建链表*/
{if(p1->number!=p3->number)
{printf("学号重复,请重输!\n");
/*当输入的学号已经存在，程序报错，返回前面重新输入*/
scanf("%s",&p1->name);/*输入学生姓名*/
printf("请输入c成绩(0~100)：");
scanf("%f",&p1->cyuyan);/*输入c成绩，成绩应在0-100*/
while(p1->cyuyan<0||p1->cyuyan>100)
printf("输入错误，请重新输入c成绩");
scanf("%f",&p1->cyuyan);}/*输入错误，重新输入c成绩直到正确为止*/
printf("请输入vb成绩(0~100)：");
scanf("%f",&p1->vbyuyan);/*输入vb成绩，成绩应在0-100*/
while(p1->vbyuyan<0||p1->vbyuyan>100)
printf("输入错误，请重新输入vb成绩");
scanf("%f",&p1->vbyuyan);}/*输入错误，重新输入vb成绩直到正确为止*/
printf("请输入sql成绩(0~100)：");
scanf("%f",&p1->sqlyuyan);/*输入sql成绩，成绩应在0-100*/
while(p1->sqlyuyan<0||p1->sqlyuyan>100)
printf("输入错误，请重新输入sql成绩");
scanf("%f",&p1->sqlyuyan);}/*输入错误，重新输入sql成绩直到正确为止*/
if(max->number>p1->number)
max->number=p1->number;
/*交换前后结点中的学号值，使得学号大者移到后面的结点中*/
strcpy(max->name,p1->name);
/*交换前后结点中的姓名，使之与学号相匹配*/
max->cyuyan=p1->cyuyan;
/*交换前后结点中的c成绩，使之与学号相匹配*/
max->vbyuyan=p1->vbyuyan;
/*交换前后结点中的vb成绩，使之与学号相匹配*/
max->sqlyuyan=p1->sqlyuyan;
/*交换前后结点中的sql成绩，使之与学号相匹配*/
max=head;p1=head;/*重新使max,p指向链表头*/
printf("输入的学生数为:%d个!\n",n);
/*==============================================================================================*/
/*==============================================================================================*/
/*函数load2311，功能:从文件读入学生记录*/
printf("请输入文件路径及文件名:");
scanf("%s",filepn);/*输入文件路径及名称*/
if((fp=fopen(filepn,"r+"))==NULL)
printf("不能打开文件!\n");
fscanf(fp,"考试成绩管理系统\n");
fscanf(fp,"作者:欣杰班级：信息E3学号：24\n");
fscanf(fp,"-----------------------------------------\n");
fscanf(fp,"|学号\t|姓名\t|c\t|vb\t|sql\t|\n");
fscanf(fp,"-----------------------------------------\n");/*读入表格域*/
printf("考试成绩管理系统\n");
printf("作者:欣杰班级：信息E3学号：24\n");
printf("-----------------------------------------\n");
printf("|学号\t|姓名\t|c\t|vb\t|sql\t|\n");
printf("-----------------------------------------\n");/*打印表格域*/
p1=(score*)malloc(LEN);/*开辟一个新单元*/
fscanf(fp,"%d%s%f%f%f",&p1->number,p1->name,&p1->cyuyan,&p1->vbyuyan,&p1->sqlyuyan);
printf("|%d\t|%s\t|%.1f\t|%.1f\t|%.1f\t|\n",p1->number,p1->name,p1->cyuyan,p1->vbyuyan,p1->sqlyuyan);
p1=(score*)malloc(LEN);/*开辟一个新单元*/
fscanf(fp,"%d%s%f%f%f\n",&p1->number,p1->name,&p1->cyuyan,&p1->vbyuyan,&p1->sqlyuyan);
printf("|%d\t|%s\t|%.1f\t|%.1f\t|%.1f\t|\n",p1->number,p1->name,p1->cyuyan,p1->vbyuyan,p1->sqlyuyan);
}printf("-----------------------------------------\n");/*表格下线*/
fclose(fp);/*结束读入，关闭文件*/
/*==============================================================================================*/
/*==============================================================================================*/
score*add2311(score*head,score*stu)
/*函数add2311,功能：追加学生资料,并且将所有学生资料按学号排序*/
p3=stu=(score*)malloc(LEN);/*开辟一个新单元*/
printf("\n输入要增加的学生的资料!");
repeat4: printf("请输入学生学号(学号应大于0)：");
printf("输入错误，请重新输入学生学号:");
scanf("%d",&stu->number);}/*输入错误，重新输入学号*/
/******************************************************/
goto end2;/*当输入的学号为0时，转到末尾，结束追加*/
{if(stu->number!=p3->number)
{printf("学号重复,请重输!\n");
/*当输入的学号已经存在，程序报错，返回前面重新输入*/
/******************************************************/
scanf("%s",stu->name);/*输入学生姓名*/
printf("请输入c成绩(0~100)：");
scanf("%f",&stu->cyuyan);/*输入c成绩，成绩应在0-100*/
while(stu->cyuyan<0||stu->cyuyan>100)
printf("输入错误，请重新输入c成绩");
scanf("%f",&stu->cyuyan);}/*输入错误，重新输入c成绩直到正确为止*/
printf("请输入vb成绩(0~100)：");
scanf("%f",&stu->vbyuyan);/*输入vb成绩，成绩应在0-100*/
while(stu->vbyuyan<0||stu->vbyuyan>100)
printf("输入错误，请重新输入vb成绩");
scanf("%f",&stu->vbyuyan);}/*输入错误，重新输入vb成绩直到正确为止*/
printf("请输入sql成绩(0~100)：");
scanf("%f",&stu->sqlyuyan);/*输入sql成绩，成绩应在0-100*/
while(stu->sqlyuyan<0||stu->sqlyuyan>100)
printf("输入错误，请重新输入sql成绩");
scanf("%f",&stu->sqlyuyan);}/*输入错误，重新输入sql成绩直到正确为止*/
{head=p0;p0->next=NULL;}/*当原来链表为空时，从首结点开始存放资料*/
if(p1->next==NULL)/*找到原来链表的末尾*/
p0->next=NULL;/*将它与新开单元相连接*/
while(p1->next!=NULL)/*还没找到末尾，继续找*/
if(max->number>p1->number)
max->number=p1->number;
/*交换前后结点中的学号值，使得学号大者移到后面的结点中*/
strcpy(max->name,p1->name);
/*交换前后结点中的姓名，使之与学号相匹配*/
max->cyuyan=p1->cyuyan;
/*交换前后结点中的c成绩，使之与学号相匹配*/
max->vbyuyan=p1->vbyuyan;
/*交换前后结点中的vb成绩，使之与学号相匹配*/
max->sqlyuyan=p1->sqlyuyan;
/*交换前后结点中的sql成绩，使之与学号相匹配*/
max=head;p1=head;/*重新使max,p指向链表头*/
printf("现在的学生数为:%d个!\n",n);
/*==============================================================================================*/
/*==============================================================================================*/
/*函数search2311,功能：查询学生成绩*/
printf("输入要查询的学生的学号,");
{printf("\n没有任何学生资料!\n");return(head);}
printf("-----------------------------------------\n");
printf("|学号\t|姓名\t|c\t|vb\t|sql\t|\n");
printf("-----------------------------------------\n");/*打印表格域*/
while(number!=p1->number&&p1->next!=NULL)
{printf("|%d\t|%s\t|%.1f\t|%.1f\t|%.1f\t|\n",p1->number,p1->name,p1->cyuyan,p1->vbyuyan,p1->sqlyuyan);
printf("-----------------------------------------\n");}/*打印表格域*/
printf("%d不存在此学生!\n",number);
printf("输入要查询的学生的学号,");
/*==============================================================================================*/
/*==============================================================================================*/
score*del2311(score*head)/*函数del2311，功能：删除学生资料*/
printf("输入要删除的学生的学号(输入0时退出):");
while(number!=0)/*输入学号为0时退出*/
printf("\n没有任何学生资料!\n");
while(number!=p1->number&&p1->next!=NULL)
/*p1指向的不是所要找的首结点，并且后面还有结点*/
/*若p1指向的是首结点，把地二个结点地址赋予head*/
/*否则将下一个结点地址赋给前一结点地址*/
printf("删除:%d\n",number);n=n-1;
printf("%d不存在此学生!\n",number);
printf("输入要删除的学生的学号:");
printf("现在的学生数为:%d个!\n",n);
/*==============================================================================================*/
/*==============================================================================================*/
/*函数print2311,功能：显示学生成绩*/
{printf("\n没有任何学生资料!\n");}
printf("-----------------------------------------\n");
printf("|学号\t|姓名\t|c\t|vb\t|sql\t|\n");
printf("-----------------------------------------\n");/*打印表格域*/
{printf("|%d\t|%s\t|%.1f\t|%.1f\t|%.1f\t|\n",p->number,p->name,p->cyuyan,p->vbyuyan,p->sqlyuyan);
printf("-----------------------------------------\n");/*打印表格域*/
p=p->next;}while(p!=NULL);/*打印完成了*/
/*==============================================================================================*/
/*==============================================================================================*/
score*statistics2311(score*head)
/*函数statistics2311,功能：统计学生成绩*/
float sum1=0,sum2=0,sum3=0,ave1=0,ave2=0,ave3=0,max=0,min;
printf("1个人总分和平均分\t2单科平均分\t3总分最高分\t4总分最低分\n");
{printf("\n没有任何学生资料!\n");return(head);}/*链表为空*/
printf("---------------------------------------------------------\n");
printf("|学号\t|姓名\t|c\t|vb\t|sql\t|总分\t|平均分\t|\n");
printf("---------------------------------------------------------\n");/*打印表格域*/
sum1=p->cyuyan+p->vbyuyan+p->sqlyuyan;/*计算个人总分*/
ave1=sum1/3;/*计算个人平均分*/
printf("|%d\t|%s\t|%.1f\t|%.1f\t|%.1f\t|%.1f\t|%.1f\t|\n",p->number,p->name,p->cyuyan,p->vbyuyan,p->sqlyuyan,sum1,ave1);
printf("---------------------------------------------------------\n");/*打印表格域*/
{printf("\n没有任何学生资料!\n");return(head);}/*链表为空*/
sum3=sum3+p->sqlyuyan;/*计算总分*/
p=p->next;/*使p指向下一个结点*/
printf("c平均分是%.1f\n",ave1);
printf("vb平均分是%.1f\n",ave2);
printf("sql平均分是%.1f\n",ave3);/*打印结果*/
{printf("\n没有任何学生资料!\n");return(head);}/*链表为空*/
max=p->cyuyan+p->vbyuyan+p->sqlyuyan;
sum1=p->cyuyan+p->vbyuyan+p->sqlyuyan;/*计算个人总分*/
printf("总分最高分:%.1f",max);
{printf("\n没有任何学生资料!\n");return(head);}/*链表为空*/
min=p->cyuyan+p->vbyuyan+p->sqlyuyan;
{sum2=p->cyuyan+p->vbyuyan+p->sqlyuyan;
printf("总分最低分:%.1f",min);
default:printf("输入错误,请重试!\n");
/*==============================================================================================*/
/*==============================================================================================*/
/*函数save2311,功能：保存学生的资料*/
char filepn[20];/*用来存放文件保存路径以及文件名*/
printf("请输入文件路径及文件名:");
if((fp=fopen(filepn,"w+"))==NULL)
printf("不能打开文件!\n");
fprintf(fp,"考试成绩管理系统\n");
fprintf(fp,"作者:欣杰班级：信息E3学号：24\n");
fprintf(fp,"-----------------------------------------\n");
fprintf(fp,"|学号\t|姓名\t|c\t|vb\t|sql\t|\n");
fprintf(fp,"-----------------------------------------\n");
fprintf(fp,"%d\t%s\t%.1f\t%.1f\t%.1f\t\n",p1->number,p1->name,p1->cyuyan,p1->vbyuyan,p1->sqlyuyan);
p1=p1->next;/*下移一个结点*/
printf("文件已经保存!\n");
/*==============================================================================================*/
/*==============================================================================================*/
/*定义排序函数。此函数带回一个指向链表头的指针*/
{printf("\n没有任何学生资料，请先建立链表!\n");return(head);}/*链表为空*/
printf("1按学生学号排序\t2按学生姓名排序\t3按c成绩排序\n");
printf("4按vb成绩排序\t5按sql成绩排序\t\n");
switch(x)/*用switch语句实现功能选择*/
if(max->number>p->number)
/*交换前后结点中的学号值，使得学号大者移到后面的结点中*/
strcpy(max->name,p->name);
/*交换前后结点中的姓名，使之与学号相匹配*/
/*交换前后结点中的c成绩，使之与学号相匹配*/
max->vbyuyan=p->vbyuyan;
/*交换前后结点中的vb成绩，使之与学号相匹配*/
max->sqlyuyan=p->sqlyuyan;
/*交换前后结点中的sql成绩，使之与学号相匹配*/
max=head;p=head;/*重新使max,p指向链表头*/
二、求C语言各关键字的含义。急!!!
1、else：条件语句否定分支（与 if连用）
2、typedef：用以给数据类型取别名（当然还有其他作用）
3、extern：声明变量是在其他文件正声明（也可以看做是引用变量）
4、return：子程序返回语句（可以带参数，也看不带参数）
5、unsigned：声明无符号类型变量或函数
6、continue：结束当前循环，开始下一轮循环
7、for：一种循环语句(可意会不可言传）
8、signed：生命有符号类型变量或函数
9、void：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用）
10、default：开关语句中的“其他”分支
11、volatile：说明变量在程序执行中可被隐含地改变
12、ps：这些东西上网随便一搜多的是，应该具备自己找资料得能力。
三、C语言排序
//总共给你整理了7种排序算法：希尔排序，链式基数排序，归并排序
//起泡排序，简单选择排序，树形选择排序，堆排序,先自己看看吧，
//看不懂可以再问身边的人或者查资料,既然可以上网，我相信你所在的地方信息流通方式应该还行,所有的程序全部在VC++6.0下编译通过
typedef int InfoType;//定义其它数据项的类型
#define MAXSIZE 20//一个用作示例的小顺序表的最大长度
typedef int KeyType;//定义关键字类型为整型
InfoType otherinfo;//其它数据项，具体类型在主程中定义
RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元
void ShellInsert(SqList&L,int dk)
{//对顺序表L作一趟希尔插入排序。本算法是和一趟直接插入排序相比，
// 1.前后记录位置的增量是dk,而不是1;
// 2.r[0]只是暂存单元,不是哨兵。当j<=0时,插入位置已找到。算法10.4
for(i=dk+1;i<=L.length;++i)
if LT(L.r[i].key,L.r[i-dk].key)
for(j=i-dk;j>0&<(L.r[0].key,L.r[j].key);j-=dk)
L.r[j+dk]=L.r[j];//记录后移，查找插入位置
printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);
void ShellSort(SqList&L,int dlta[],int t)
{//按增量序列dlta[0..t-1]对顺序表L作希尔排序。算法10.5
ShellInsert(L,dlta[k]);//一趟增量为dlta[k]的插入排序
printf("第%d趟排序结果:",k+1);
RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8},{55,9},{4,10}};
int dt[T]={5,3,1};//增量序列数组
/*****************************************************************/
typedef int InfoType;//定义其它数据项的类型
typedef int KeyType;//定义RedType类型的关键字为整型
struct RedType//记录类型(同c10-1.h)
InfoType otherinfo;//其它数据项
typedef char KeysType;//定义关键字类型为字符型
#include<malloc.h>// malloc()等
#include<limits.h>// INT_MAX等
#include<stdio.h>// EOF(=^Z或F6),NULL
#include<stdlib.h>// atoi()
#include<math.h>// floor(),ceil(),abs()
#include<process.h>// exit()
#include<iostream.h>// cout,cin
typedef int Status;// Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean;// Boolean是布尔类型,其值是TRUE或FALSE
#define MAX_NUM_OF_KEY 8//关键字项数的最大值
#define RADIX 10//关键字基数，此时是十进制整数的基数
struct SLCell//静态链表的结点类型
KeysType keys[MAX_NUM_OF_KEY];//关键字
InfoType otheritems;//其它数据项
SLCell r[MAX_SPACE];//静态链表的可利用空间，r[0]为头结点
int keynum;//记录的当前关键字个数
int recnum;//静态链表的当前长度
void InitList(SLList&L,RedType D[],int n)
{//初始化静态链表L（把数组D中的数据存于L中）
char c[MAX_NUM_OF_KEY],c1[MAX_NUM_OF_KEY];
int i,j,max=D[0].key;// max为关键字的最大值
L.keynum=int(ceil(log10(max)));
L.r[i].otheritems=D[i-1].otherinfo;
itoa(D[i-1].key,c,10);//将10进制整型转化为字符型,存入c
for(j=strlen(c);j<L.keynum;j++)//若c的长度<max的位数,在c前补'0'
L.r[i].keys[j]=c[L.keynum-1-j];
void Distribute(SLCell r[],int i,ArrType f,ArrType e)//算法10.15
{//静态键表L的r域中记录已按(keys[0],…,keys[i-1])有序。本算法按
//第i个关键字keys[i]建立RADIX个子表,使同一子表中记录的keys[i]相同。
// f[0..RADIX-1]和e[0..RADIX-1]分别指向各子表中第一个和最后一个记录
for(p=r[0].next;p;p=r[p].next)
j=ord(r[p].keys[i]);// ord将记录中第i个关键字映射到[0..RADIX-1]
e[j]=p;//将p所指的结点插入第j个子表中
void Collect(SLCell r[],ArrType f,ArrType e)
{//本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成
//一个链表，e[0..RADIX-1]为各子表的尾指针。算法10.16
for(j=0;!f[j];j=succ(j));//找第一个非空子表，succ为求后继函数
t=e[j];// r[0].next指向第一个非空子表中第一个结点
for(j=succ(j);j<RADIX-1&&!f[j];j=succ(j));//找下一个非空子表
r[t].next=0;// t指向最后一个非空子表中的最后一个结点
for(j=L.keynum-1;j>=0;j--)
{// L是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字
//自小到大的有序静态链表，L.r[0]为头结点。算法10.17
L.r[L.recnum].next=0;//将L改造为静态链表
{//按最低位优先依次对各关键字进行分配和收集
Distribute(L.r,i,f,e);//第i趟分配
printf("第%d趟收集后:\n",i+1);
printf("keynum=%d recnum=%d\n",L.keynum,L.recnum);
for(j=L.keynum-1;j>=0;j--)
printf(" otheritems=%d next=%d\n",L.r[i].otheritems,L.r[i].next);
void Sort(SLList L,int adr[])//改此句(类型)
{//求得adr[1..L.length]，adr[i]为静态链表L的第i个最小记录的序号
void Rearrange(SLList&L,int adr[])//改此句(类型)
{// adr给出静态链表L的有序次序，即L.r[adr[i]]是第i小的记录。
//本算法按adr重排L.r，使其有序。算法10.18(L的类型有变)
for(i=1;i<L.recnum;++i)//改此句(类型)
L.r[0]=L.r[i];//暂存记录L.r[i]
{//调整L.r[adr[j]]的记录到位直到adr[j]=i为止
RedType d[N]={{278,1},{109,2},{63,3},{930,4},{589,5},{184,6},{505,7},{269,8},{8,9},{83,10}};
printf("排序前(next域还没赋值):\n");
printf("排序后(静态链表):\n");
adr=(int*)malloc((l.recnum)*sizeof(int));
printf("排序后(重排记录):\n");
/*******************************************/
typedef int InfoType;//定义其它数据项的类型
#define MAXSIZE 20//一个用作示例的小顺序表的最大长度
typedef int KeyType;//定义关键字类型为整型
InfoType otherinfo;//其它数据项，具体类型在主程中定义
RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元
void Merge(RedType SR[],RedType TR[],int i,int m,int n)
{//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]算法10.12
for(j=m+1,k=i;i<=m&&j<=n;++k)//将SR中记录由小到大地并入TR
TR[k+l]=SR[i+l];//将剩余的SR[i..m]复制到TR
TR[k+l]=SR[j+l];//将剩余的SR[j..n]复制到TR
void MSort(RedType SR[],RedType TR1[],int s, int t)
{//将SR[s..t]归并排序为TR1[s..t]。算法10.13
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]
{//对顺序表L作归并排序。算法10.14
printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);
RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7}};
/**********************************************/
#include<malloc.h>// malloc()等
#include<limits.h>// INT_MAX等
#include<stdio.h>// EOF(=^Z或F6),NULL
#include<stdlib.h>// atoi()
#include<math.h>// floor(),ceil(),abs()
#include<process.h>// exit()
#include<iostream.h>// cout,cin
void bubble_sort(int a[],int n)
{//将a中整数序列重新排列成自小至大有序的整数序列(起泡排序)
for(i=n-1,change=TRUE;i>1&&change;--i)
int d[N]={49,38,65,97,76,13,27,49};
/****************************************************/
typedef int InfoType;//定义其它数据项的类型
#define MAXSIZE 20//一个用作示例的小顺序表的最大长度
typedef int KeyType;//定义关键字类型为整型
InfoType otherinfo;//其它数据项，具体类型在主程中定义
RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元
int SelectMinKey(SqList L,int i)
{//返回在L.r[i..L.length]中key最小的记录的序号
for(j=i+1;j<=L.length;j++)
if(L.r[j].key<min)//找到更小的
{//对顺序表L作简单选择排序。算法10.9
{//选择第i小的记录，并交换到位
j=SelectMinKey(L,i);//在L.r[i..L.length]中选择key最小的记录
printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);
RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
/************************************************/
#include<malloc.h>// malloc()等
#include<limits.h>// INT_MAX等
#include<stdio.h>// EOF(=^Z或F6),NULL
#include<stdlib.h>// atoi()
#include<math.h>// floor(),ceil(),abs()
#include<process.h>// exit()
#include<iostream.h>// cout,cin
typedef int Status;// Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean;// Boolean是布尔类型,其值是TRUE或FALSE
typedef int InfoType;//定义其它数据项的类型
#define MAXSIZE 20//一个用作示例的小顺序表的最大长度
typedef int KeyType;//定义关键字类型为整型
InfoType otherinfo;//其它数据项，具体类型在主程中定义
RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元
int i,j,j1,k,k1,l,n=L.length;
l=(int)ceil(log(n)/log(2))+1;//完全二叉树的层数
k=(int)pow(2,l)-1;// l层完全二叉树的结点总数
k1=(int)pow(2,l-1)-1;// l-1层完全二叉树的结点总数
t=(RedType*)malloc(k*sizeof(RedType));//二叉树采用顺序存储结构
for(i=1;i<=n;i++)//将L.r赋给叶子结点
for(i=k1+n;i<k;i++)//给多余的叶子的关键字赋无穷大
t[i].key<t[i+1].key?(t[(i+1)/2-1]=t[i]):(t[(i+1)/2-1]=t[i+1]);
L.r[i+1]=t[0];//将当前最小值赋给L.r[i]
for(j=1;j<l;j++)//沿树根找结点t[0]在叶子中的序号j1
t[2*j1+1].key==t[j1].key?(j1=2*j1+1):(j1=2*j1+2);
j1=(j1+1)/2-1;//序号为j1的结点的双亲结点序号
t[2*j1+1].key<=t[2*j1+2].key?(t[j1]=t[2*j1+1]):(t[j1]=t[2*j1+2]);
printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);
RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
/****************************/
typedef int InfoType;//定义其它数据项的类型
#define MAXSIZE 20//一个用作示例的小顺序表的最大长度
typedef int KeyType;//定义关键字类型为整型
InfoType otherinfo;//其它数据项，具体类型在主程中定义
RedType r[MAXSIZE+1];// r[0]闲置或用作哨兵单元
typedef SqList HeapType;//堆采用顺序表存储表示
void HeapAdjust(HeapType&H,int s,int m)//算法10.10
{//已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数
//调整H.r[s]的关键字,使H.r[s..m]成为一个大顶堆(对其中记录的关键字而言)
{//沿key较大的孩子结点向下筛选
if(j<m&<(H.r[j].key,H.r[j+1].key))
{//对顺序表H进行堆排序。算法10.11
for(i=H.length/2;i>0;--i)//把H.r[1..H.length]建成大顶堆
{//将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换
HeapAdjust(H,1,i-1);//将H.r[1..i-1]重新调整为大顶堆
printf("(%d,%d)",H.r[i].key,H.r[i].otherinfo);
RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
