数据c语言课程设计_c语言课程设计

‘壹’ c语言课程设计：数据排序算法

这是一个模板，好好研究一下就会排序这部分的题了。

‘贰’ c语言课程设计

#include<stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{
long class_1; //班级
long number; //学号
char name[20]; //姓名
float math; //数学
float c_program; //C语言
float physics; //大学物理
float english; //大学英语
float polity; //政治
float sport; //体育
float summary; //总分
float average; //平均分
}Student;
Student stud[100]; //定义结构体数组变量的大小
int i=0; //i用于记录输入的学生的个数
int menu() //菜单函数
{
int a;
printf("***********************学生信息管理系统*************************\n");
//菜单选择
printf("\t\t【1】输入学生信息\n");
printf("\t\t【2】显示所有学生的信息\n");
printf("\t\t【3】按平均分升降排序\n");
printf("\t\t【4】根据学生的学号查找学生的信息\n");
printf("\t\t【5】插入学生的信息\n");
printf("\t\t【6】删除学生的信息\n");
printf("\t\t【7】修改学生的信息\n");
printf("\t\t【8】从文件中读入数据\n");
printf("\t\t【9】将所有记录写入文件\n");
printf("\t\t【0】退出本系统\n");
printf("***********************学生信息管理系统*************************\n");
printf("请选择你要的操作【0-9】:");
scanf("%d",&a); //读入一个数
while(a<0 || a>9)
{
printf("输入错误！请重新输入。\n");
scanf("%d",&a); //输入错误就一直循环！^_^
}
system("cls"); //清屏
return(a); //返回a的值
}
int input(Student stud[]) //输入学生信息
{
char flag='Y';
while(flag=='y' || flag=='Y') //判断
{
printf("请输入该学生的班别:"); //交互输入学生信息
scanf("%ld",&stud[i].class_1);
printf("请输入该学生的学号:");
scanf("%ld",&stud[i].number);
printf("请输入该学生的姓名:");
scanf("%s",&stud[i].name);
printf("请输入该学生的“数学”分数:");
scanf("%f",&stud[i].math);
printf("请输入该学生的“C程序设计语言”分数:");
scanf("%f",&stud[i].c_program);
printf("请输入该学生的“大学物理”分数:");
scanf("%f",&stud[i].physics);
printf("请输入该学生的“大学英语”分数:");
scanf("%f",&stud[i].english);
printf("请输入该学生的“体育”分数:");
scanf("%f",&stud[i].sport);
printf("请输入该学生的“政治”分数:");
scanf("%f",&stud[i].polity);
getchar(); //用于消除回车键
stud[i].summary=stud[i].math+stud[i].c_program+stud[i]. physics
+stud[i].english+stud[i].sport+stud[i].polity;
stud[i].average=stud[i].summary/6;
printf("该学生的总分为：%6.2f\t平均分为：%6.2f\n",stud[i].summary,stud[i].average);
i++;
printf("继续输入学生信息请按:Y or y,退出请按：N or n.\n");
scanf("%c",&flag); //判断是否继续输入
}
printf("按任意键回主菜单\n");
getchar();
system("cls");
return(i);
}
void Display(Student stud[],int n) //显示所有记录
{
int k;
if(n==0)
printf("暂无学生记录!\n");
else
{
printf(" 班别学号姓名数学 C语言物理英语体育政治总分平均分\n");
for(k=0;k<n;k++) //循环输出
{
printf("%7ld",stud[k].class_1);
printf("%7ld",stud[k].number);
printf("%9s",stud[k].name);
printf("%7.2f",stud[k].math);
printf("%7.2f",stud[k].c_program);
printf("%7.2f",stud[k].physics);
printf("%7.2f",stud[k].english);
printf("%7.2f",stud[k].sport);
printf("%7.2f",stud[k].polity);
printf("%7.2f",stud[k].summary);
printf("%8.2f\n",stud[k].average);
}
}
system("pause");
system("cls");
}
void Sort(Student stud[],int i) //按平均分排序
{
int m,n,k; //m,n为循环变量
Student t;
for(m=0;m<i-1;m++) //排序
for(n=m+1;n<i;n++)
if(stud[m].average<stud[n].average)
{
t=stud[m];
stud[m]=stud[n];
stud[n]=t;
}
printf("排序后的顺序为:\n");
printf(" 班别学号姓名数学 C语言物理英语体育政治总分平均分\n");
for(k=0;k<i;k++) //循环输出
{
printf("%7ld",stud[k].class_1);
printf("%7d",stud[k].number);
printf("%9s",stud[k].name);
printf("%7.2f",stud[k].math);
printf("%7.2f",stud[k].c_program);
printf("%7.2f",stud[k].physics);
printf("%7.2f",stud[k].english);
printf("%7.2f",stud[k].sport);
printf("%7.2f",stud[k].polity);
printf("%7.2f",stud[k].summary);
printf("%8.2f\n",stud[k].average);
}
system("pause");
system("cls");
}
void Search(Student stud[],int i) //查找并显示一个记录
{
int p,k; //p为要查找的学生学号，t为循环节，s用来判断循环是否结束
char flag='y';
while(flag=='y' || flag=='Y')
{
printf("请输入要查找的学生学号：");
scanf("%d",&p);
getchar();
for(k=0;p!=stud[k].number && k<i;k++);
if(k==i)printf("该学号不存在！\n");
else {
printf("该学生的信息为：\n");
printf(" 班别学号姓名数学 C语言物理英语体育政治总分平均分\n");
printf("%7ld",stud[k].class_1);
printf("%7ld",stud[k].number);
printf("%9s",stud[k].name);
printf("%7.2f",stud[k].math);
printf("%7.2f",stud[k].c_program);
printf("%7.2f",stud[k].physics);
printf("%7.2f",stud[k].english);
printf("%7.2f",stud[k].sport);
printf("%7.2f",stud[k].polity);
printf("%7.2f",stud[k].summary);
printf("%8.2f\n",stud[k].average);
}
printf("继续查找学生信息请输入:Y or y,退出输入：N or n\n");
scanf("%c",&flag); //判断是否继续输入
}
system("cls");
}
int Insert(Student stud[],int i) //插入学生的信息
{
char flag='Y';
while(flag=='y' || flag=='Y')
{
printf("请输入要插入学生的班别:"); //交互输入学生信息
scanf("%ld",&stud[i].class_1);
printf("请输入要插入学生的学号:");
scanf("%ld",&stud[i].number);
printf("请输入要插入学生的姓名:");
scanf("%s",&stud[i].name);
printf("请输入要插入学生的“数学”分数:");
scanf("%f",&stud[i].math);
printf("请输入要插入学生的“C程序设计语言”分数:");
scanf("%f",&stud[i].c_program);
printf("请输入要插入学生的“大学物理”分数:");
scanf("%f",&stud[i].physics);
printf("请输入要插入学生的“大学英语”分数:");
scanf("%f",&stud[i].english);
printf("请输入要插入学生的“体育”分数:");
scanf("%f",&stud[i].sport);
printf("请输入要插入学生的“政治”分数:");
scanf("%f",&stud[i].polity);
getchar();
stud[i].summary=stud[i].math+stud[i].c_program+stud[i]. physics
+stud[i].english+stud[i].sport+stud[i].polity;
stud[i].average=stud[i].summary/6;
printf("该学生的总分为：%6.2f\n",stud[i].summary);
printf("该学生的平均分为：%6.2f\n",stud[i].average);
i++;
printf("继续输入学生信息请输入:Y or y,退出输入：N or n\n");
scanf("%c",&flag); //判断是否继续输入
}
getchar();
printf("是否需要排序，需要请按‘Y’或‘y’；不需要请按‘N’或‘n’.\n");
flag=getchar();
if(flag=='y' || flag=='Y')Sort(stud,i);
system("cls");
return(i);
}
int Delete(Student stud[],int i) //根据输入的学号删除学生的信息
{
long s;
int t,p;
char a='Y'; //判断循环是否继续
while(a=='y' || a=='Y')
{
printf("请输入需要删除学生的学号:\n"); //采用交互式删除
scanf("%ld",&s);
getchar(); //消除回车键的影响
for(t=0;t<i && s!=stud[t].number;t++);
if(s==stud[t].number)
{
for(p=t;p<i;p++)
stud[p]=stud[p+1];
i=i-1;
printf("删除成功！\n");
}
else printf("没有找到要删除的学号！\n");
printf("是否继续删除，继续请按'Y'或'y',退出请按'N'或'n'.\n");
a=getchar(); //判断是否继续
getchar(); //消除回车键的影响
}
system("cls");
return(i);
}
void change(Student stud[],int i) //修改学生的信息
{
long p=0; //p用来表示要删除的学生的学号
int k; //k为循环变量
char a='y';
while(a=='y' || a=='Y')
{
printf("\t\t学生信息修改：\n");
printf("请输入要修改的学生的学号:\n");
scanf("%ld",&p);
for(k=0;p!=stud[k].number && k<i;k++);
if(k==i)printf("无法找到该学生的信息\n");
else {
printf("该学生的信息为：\n");
printf(" 班别学号姓名数学 C语言物理英语体育政治总分平均分\n");
printf("%7ld",stud[k].class_1);
printf("%7ld",stud[k].number);
printf("%9s",stud[k].name);
printf("%7.2f",stud[k].math);
printf("%7.2f",stud[k].c_program);
printf("%7.2f",stud[k].physics);
printf("%7.2f",stud[k].english);
printf("%7.2f",stud[k].sport);
printf("%7.2f",stud[k].polity);
printf("%7.2f",stud[k].summary);
printf("%8.2f\n",stud[k].average);
printf("请输入该学生的新信息:\n");
printf("请输入该学生的班级:"); //交互输入学生信息
scanf("%d",&stud[k].class_1);
printf("请输入该学生的学号:");
scanf("%d",&stud[k].number);
printf("请输入该学生的姓名:");
scanf("%s",&stud[k].name);
printf("请输入该学生的“数学”分数:");
scanf("%f",&stud[k].math);
printf("请输入该学生的“C程序设计语言”分数:");
scanf("%f",&stud[k].c_program);
printf("请输入该学生的“大学物理”分数:");
scanf("%f",&stud[k].physics);
printf("请输入该学生的“大学英语”分数:");
scanf("%f",&stud[k].english);
printf("请输入该学生的“体育”分数:");
scanf("%f",&stud[k].sport);
printf("请输入该学生的“政治”分数:");
scanf("%f",&stud[k].polity);
getchar();
stud[k].summary=stud[k].math+stud[k].c_program+stud[k]. physics
+stud[k].english+stud[k].sport+stud[k].polity;
stud[k].average=stud[k].summary/6;
printf("修改成功!\n");
}
printf("是否继续修改，继续请按'Y'或'y',退出请按'N'或'n'.\n");
a=getchar(); //判断是否继续
}
system("pause");
system("cls");
}
int Read(Student stud[],int i) //从文件中读入学生信息
{
int k=i;
FILE *fp; //定义一个文件类型的指针
char filename[20]; //定义文件名
printf("请输入文件名:\n");
scanf("%s",&filename); //输入文件名
if((fp=fopen(filename,"rb"))==NULL) //打开文件
{
printf("无法打开该文件！\n"); //打开失败信息
return 0;
}
printf("从文件%s中读入的数据为：\n",filename);
printf(" 班别学号姓名数学 C语言物理英语体育政治总分平均分\n");
while(!feof(fp))
{
fread(&stud[k],sizeof(Student),1,fp);
printf("%7ld",stud[k].class_1);
printf("%7ld",stud[k].number);
printf("%9s",stud[k].name);
printf("%7.2f",stud[k].math);
printf("%7.2f",stud[k].c_program);
printf("%7.2f",stud[k].physics);
printf("%7.2f",stud[k].english);
printf("%7.2f",stud[k].sport);
printf("%7.2f",stud[k].polity);
printf("%7.2f",stud[k].summary);
printf("%8.2f\n",stud[k].average);
k++;
}
fclose(fp);
printf("读入成功,\n");
system("pause");
system("cls");
return(k);
}
void Save(Student stud[],int i) //将所有记录写入文件
{
int k=0;
FILE *fp; //定义文件指针
char filename[20]; //定义文件名
printf("请输入你要存储学生信息的文件名:"); //输入文件名
scanf("%s",&filename);
if((fp=fopen(filename,"wb"))==NULL) //打开文件
{
printf("无法打开该文件！\n"); //打开失败信息
return;
}
printf("保存到文件%s里的信息为:\n",filename);
while(k<i)
{
fwrite(&stud[k],sizeof(Student),1,fp);
printf("%7ld",stud[k].class_1);
printf("%7d",stud[k].number);
printf("%9s",stud[k].name);
printf("%7.2f",stud[k].math);
printf("%7.2f",stud[k].c_program);
printf("%7.2f",stud[k].physics);
printf("%7.2f",stud[k].english);
printf("%7.2f",stud[k].sport);
printf("%7.2f",stud[k].polity);
printf("%7.2f",stud[k].summary);
printf("%8.2f\n",stud[k].average);
k++;
}
fclose(fp);
printf("信息保存成功，");
system("pause");
system("cls");
}
int main() //主函数
{
int n=0;
while(1)
{
switch(menu()) //选择判断要执行的语句
{
case 1:
printf("\n*******输入学生信息*******\n");
//输入学生信息
n=input(stud);break;
case 2:
printf("\n*******显示所有学生的信息*******\n");
//显示所有学生的信息
Display(stud,n);break;
case 3:
printf("\n*******按平均分升降排序*******\n");
//给学生成绩排序
Sort(stud,n);break;
case 4:
printf("\n*******根据学生的学号查找学生的信息*******\n");
//根据输入的学号查找学生的信息
Search(stud,n);break;
case 5:
printf("\n*******插入学生的信息*******\n");
//插入学生的信息
n=Insert(stud,n);break;
case 6:
printf("\n*******删除学生的信息*******\n");
//删除学生的信息
n=Delete(stud,n);break;
case 7:
printf("\n*******修改学生的信息*******\n");
//修改学生的信息
change(stud,n);break;
case 8:
printf("\n*******从文件中读入数据*******\n");
//从文件中读入数据
n=Read(stud,n);break;
case 9:
printf("\n*******将所有记录写入文件*******\n");
//将所有记录写入文件
Save(stud,n);break;
case 0:
printf("\n*******感谢您的使用*******\n");
//结束程序
exit(0);
}
}
return 0;
}

‘叁’ C语言数据结构课程设计-----24点游戏

问题已解决，楼主请参照

下面的链接里有对该问题所采用的算法的详细讨论

谨祝，
学习进步
另外,虚机团上产品团购,超级便宜

‘肆’ c语言课程设计

这个，，，，太复杂了呀，而且你才只给5分，就算会的话，估计也没有人给你做的，，若换成是你的话，你给做吗！我问这样的问题都给100分的！你一点诚心都没有啊！

‘伍’ c语言的课程设计问题该怎么做

这个程序设计其实很简单的。
（1）这个要求最简单，用prinf语句直接输出相关信息即可。
（2）这个要求也容易，用for语句实现循环，循环体用sanf语句，加system("pause");语句，就可以实现键盘输入回车确定。接受键盘数据的变量要用数组，这个关系到后面的统计排序。用if(a【i】==0) break; 即输入0回车就退出循环。
（3）通过for语句对数组a进行遍历，统计之前输入序号的个数（其实在（2）中就可以统计）保存另一个数组b中。然后对这个数组b的数据进行降序排列。
（4）这个要求只是考查C语言创建、读取和写入文件操作的要求而已，熟悉一下相关代码使用方法即可，分别写入数组a、数组b就行了。

‘陆’ C语言课程设计

//我以前的作业

游戏说明
1．开始游戏
1）系统随机产生一位不重复的N位数字。N的大小与等级有关。
初级:N=3 中级:N=4 高级:N=5
2）游戏者输入所猜的不重复数字，并按回车提交。提交的数据
数应与N的大小一致，当数据位数大于N时，只取前N位。
3）系统将提交的数与它自动产生的数进行比较，输出结果“*A*B”形式。其中A代表数字正确相应位置也正确，B代表数字正确但位置不正确。如:1A3B表示游戏者有1个数字的位置正确且数值也正确，除此以外,游戏者还猜对了3个数字，但位置不对，即游戏者已经猜出4位数据，但有3个数据位置不对！
4）游戏者有限定次数的猜测机会，在规定次数内完成，则游戏成功，否则，游戏失败。其中，猜测次数与等级有关:
初级：10次中级：9次高级：8次。
5）按完成游戏所用的时间和次数计算游戏者所得分数，游戏等级越高，猜测所用的次数越少，得分越高！若游戏者得分比系统已经保存的分数的高，将提示要求输入游戏者信息，并且保存在最佳排行之中。
2.等级设置
6）游戏者可以自行设置游戏等级：初级，中级和高级。
3．最佳排行
在最佳排行中，游戏者可以查看当前游戏的最佳排行。
4．游戏说明
在游戏说明中，游戏者可以查看游戏规则。

三.总体设计
本课程设计对模块设计的要求如下：
（1）要求使用多文件方式实现设计；
（2）要求在各个文件内实现结构化设计；
（3）每个模块作为一个单独的C文件，每个文件内的函数如表所示，表中给出了各个函数的功能说明。
（4）宏和数据结构等放在头文件中，并使用条件编译。
（1）文件及函数组成
源文件函数名或其他成分功能
record.h
ASK 宏定义
结构声明结构声明
库函数及函数原型声明
game_ control.c Game_rank 设置游戏等级
Game_explain 输出游戏说明
game_ register.c Tiptop_record 记录最高分
Tiptop_output 输出最佳排行
game.c Game_main 开始游戏中心
Build_number 获取系统随机数字
Game_in_out 获取游戏者数据和输出结果
Time_command 时间控制
Game_result 游戏结果处理输出
record.c main 主函数
Menu_select 选择菜单
manage_menu 处理菜单

（2）函数设计
1.头部文件
文件名称：record.h
功能：声明函数原型，包含文件及自定义宏和数据结构。
要求：报告是否能正常打开文件执行操作。
2. 设置游戏等级函数
函数原型：void Game_rank(void)
功能：可由游戏者自行设置游戏等级
参数：void
返回值：void
要求：如果游戏者没有进行等级设定，则默认初级进行游戏。
3. 输出游戏说明函数
函数原型：void Game_ explain()
功能：输出游戏规则说明
参数：void
返回值：void
要求：说明游戏相应的按键，保证游戏者按照说明。
4. 记录最高分函数：
函数原型：void Tiptop_register(int)
功能：把从Get_player函数得到的游戏者信息和游戏的积分信息一同保存到指定路径的Tiptop_register.dat文件中
参数：int S；S为游戏积分
返回值：void
要求：要求把Tiptop1.txt(初级最高分) Tiptop2.txt(中级最高分) Tiptop3.txt(高
级最高分)原来有的信息替换为现在的信息，并且只有积分大于原有信息的第
十名，才会被以替换的方式记录；并且是降序的方式排列的。
5. 输出最佳排行函数：
函数原型：void Tiptop_out()
功能：输出最佳排行信息
参数：void
返回值：void
要求：没有信息的时候输出提示，有信息时按降序排列输出全部信息。
6. 开始游戏中心函数
函数原型：void Game_main()
功能：调用Time_ control 、Build_number等函数，进行游戏的整体控制
参数：void
返回值：void
要求：注意函数的完整性，保证游戏顺利进行，注意没有设置等级时候，默认C=1！
7. 获取系统随机数字函数
函数原型：int *Build_number()
功能：系统调用<time.h>文件，利用srand((unsigned) time(&)产生1个N位随机数字，供游戏者猜测
参数：void
返回值：int 8=*i：指向产生的随机数字构成的数组的指针
要求：产生的数字是随机的，并且是不重复的，总共产生N（依据游戏等级而定）位数字，组成数组[初级为3个数字]。
8. 获取游戏者游戏数据和输出游戏进程结果函数
函数原型：void Course_in_out()
功能：把游戏者猜的数据读入内存，并且分析得出结果，并输出结果
参数：void
返回值：void
要求：用A或B的代码表示本次的结果，其中A表示数值对位置也对，B表示数值对，但位置错了！每次得到游戏者的猜测数据都要分析得出结果并输出结果，以便游戏者的下一次猜测。
9. 时间控制函数
函数原型：int Time_ control()
功能：利用<dos.h>和<time.h>文件，得到玩游戏的总时间，计算游戏积分。
参数：void
返回值：int Time：游戏前后的时间差异
要求：得到的时间是以秒为单位，数据是整型数据。
10. 游戏结果处理输出函数
函数原型：void Game_result(int m )
功能：计算，得出最后游戏积分
参数：int m：整个游戏的时间
返回值：void
要求：按照游戏等级，设置不同的游戏积分方式。
11. 主函数：
函数原型：void main()
功能：调用各个子函数，实现整体程序的运行
参数：void
返回值: void
要求：控制整个游戏的顺利进行。
12. 选择菜单函数：
函数原型：void Menu_select()
功能：得到Handle_menu的返回值，由一个switch语句选择开始，等级，最佳排行，游戏说明，结束等菜单操作。
参数：void
返回值：void
要求：由Handle_menu得到数据可循环得到，直到得到数字5时，选择退出菜单，方可退出游戏，否则一直循环程序！
13. 处理菜单函数：
函数原型：int Handle_menu()
功能：输出菜单选择提示，并由cin语句实现游戏者的输入，输入选择相应菜单对应的菜单序号，并把相应的值传给Menu_select函数
参数：void
返回值：int n：选择相应菜单的菜单序号
要求：输入的值不是相应的菜单的序号时返回0值，否则返回游戏者的输入值，以选择相应菜单。

四.程序代码
1. record.h
#include"time.h"
#include<dos.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//结构体
#define MAXSIZE 20
typedef long int ElemType; //定义结构体tiptop，存放游戏者的最高分等信息
typedef struct tiptop
{
ElemType data;
char name[MAXSIZE];
char grade[MAXSIZE];
int year;
int month;
int day;
char week[MAXSIZE];
int hour;
int minute;
int second;
}tiptop;
//全局变量
int C; //C为等级设置变量
//函数声明
void Menu_select(); //选择菜单函数
int manage_menu(); //处理菜单函数
void Tiptop_record(int); //记录最高分函数
void Tiptop_output(); //输出最佳排行函数
void Game_rank(); //设置游戏等级函数
void Game_explain(); //输出游戏说明函数
void Game_main(); //开始游戏中心函数
int *Build_number(); //获取系统随机数字函数
void Game_in_out(); //获取游戏数据和输出游戏进程结果函数
int Time_command(); //时间控制函数
void Game_result(int); //游戏结果处理输出函数

2. game_ control.c
#include"record.h"
//**********************
// 设置游戏等级函数
//**********************
void Game_rank()
{
FILE *fp;
printf("\t******************************\n");
printf("\t************1:初级************\n");
printf("\t************2:中级************\n");
printf("\t************3:高级************\n");
printf("\t******************************\n");
printf("\t请选择游戏等级：\t");
loop:
scanf("%d",&C);
if(C<1||C>3)
{
printf("\t输入有误！请重新输入：\t");
goto loop;
}
if((fp=fopen("C.txt","w"))==NULL)
{
printf("打开C.txt文件失败!");
exit(1);
}
fwrite(&C,sizeof(int),1,fp);
fclose(fp);
if(C==1)
printf("\t等级设置为初级!\n");
if(C==2)
printf("\t等级设置为中级!\n");
if(C==3)
printf("\t等级设置为高级!\n");
printf("\n");

}
//****************
//输出游戏说明函数
//****************
void Game_explain()
{
printf("游戏说明:\n");
printf("\t**********************************************************\n");
printf("\t**********************************************************\n");
printf("\t①：游戏开始，系统随机产生一位不重复的N位数字。N的大小与等级\n");
printf("\t有关:\n");
printf("\t初级:N=3\t中级:N=4\t高级:N=5\t\n");
printf("\t②：游戏者输入所猜的不重复数字，并按回车提交。\n");
printf("\t提交的数据位数应与N的大小一致，当数据位数大于N时，只取前N位;\n");
printf("\t③：系统将提交的数与它自动产生的数进行比较，输出结果\n");
printf("\t“*A*B”形式。其中A代表数字正确相应位置也正确，B代\n");
printf("\t表数字正确但位置不正确。如:1A3B表示游戏者有1个数字的位置\n");
printf("\t正确且数值也正确，除此以外,游戏者还猜对了3个数字，但位置不\n");
printf("\t对，即游戏者已经猜出4位数据，但有3个数据位置不对！\n");
printf("\t④：游戏者有限定次数的猜测机会，在规定次数内完成，\n");
printf("\t则游戏成功。否则，游戏失败。其中，猜测次\n");
printf("\t数与等级有关:\n");
printf("\t初级：10次\t中级：9次\t高级：8次。\t\n");
printf("\t⑤：按完成游戏所用的时间和次数计算游戏者所得分数，\n");
printf("\t游戏等级越高，猜测所用的次数越少，得分越高！\n");
printf("\t若游戏者得分比系统已经保存的分数的高，将提示要求\n");
printf("\t输入游戏者信息，并且保存在最佳排行之中。\n");
printf("\t⑥：游戏者可以自行设置等级！\n");
printf("\t**********************************************************\n");
printf("\t**********************************************************\n");
printf("\n");
}
3. game_ register.c
#include"record.h"
//**************
//记录最高分函数
//**************
void Tiptop_record(int S)
{
FILE *fp;
tiptop n;
char *week[]={"星期天","星期一","星期二","星期三","星期四","星期五",
"星期六"};
time_t timep;
struct tm *t;
printf("\t恭喜您!\n");
printf("\t您获得本游戏的最高分!\n");
//获取名字
printf("\t请输入您的姓名:");
printf("\t");
scanf("%s",n.name);
//获取时间
time(&timep);
t=gmtime(&timep);
t->tm_year=1900+t->tm_year;
t->tm_mon=1+t->tm_mon;
t->tm_hour=8+t->tm_hour;
n.year=t->tm_year;
n.month=t->tm_mon;
n.day=t->tm_mday;
strcpy(n.week,week[t->tm_wday]);
n.hour=t->tm_hour;
n.minute=t->tm_min;
n.second=t->tm_sec;
//获取等级
if(C==1)
strcpy(n.grade,"初级");
if(C==2)
strcpy(n.grade,"中级");
if(C==3)
strcpy(n.grade,"高级");
//获取分数
n.data=S;
if(C==1)
{
if((fp=fopen("tiptop1.txt","w"))==NULL)
{
printf("\t打开tiptop1.txt文件失败!");
exit(1);
}
fwrite(&n,sizeof(struct tiptop),1,fp);
fclose(fp);
}
if(C==2)
{
if((fp=fopen("tiptop2.txt","w"))==NULL)
{
printf("\t打开tiptop2.txt文件失败!");
exit(1);
}
fwrite(&n,sizeof(struct tiptop),1,fp);
fclose(fp);
}
if(C==3)
{
if((fp=fopen("tiptop3.txt","w"))==NULL)
{
printf("\t打开tiptop3.txt文件失败!");
exit(1);
}
fwrite(&n,sizeof(struct tiptop),1,fp);
fclose(fp);
}
}
//****************
//输出最佳排行函数
//****************
void Tiptop_output()
{
int i;
FILE *fp;
tiptop p,q,r;
if((fp=fopen("tiptop1.txt","r"))==NULL)
{
printf("还没有最佳排行!");
exit(1);
}
fread(&p,sizeof(struct tiptop),1,fp);
fclose(fp);
if((fp=fopen("tiptop2.txt","r"))==NULL)
{
printf("还没有最佳排行!");
exit(1);
}
fread(&q,sizeof(struct tiptop),1,fp);
fclose(fp);
if((fp=fopen("tiptop3.txt","r"))==NULL)
{
printf("还没有最佳排行!");
exit(1);
}
fread(&r,sizeof(struct tiptop),1,fp);
fclose(fp);
if(p.data==0&&q.data==0&&r.data==0)
{
printf("\t暂无最高分信息!");
printf("\n");
printf("\t是否直接进入游戏?刷新最佳排行信息?\n");
printf("\t1:是\t2:否\n");
printf("\t");
i=0;
scanf("%d",&i);
if(i==1)
{
printf("\t请设置游戏等级: \n");
Game_rank();
Game_main();
}
else
Menu_select();
}
else
{
printf("\t最佳排行:\n");
printf("\t等级\t姓名\t分数\t游戏时间\n");
if(p.data!=0)
{
printf("\t%s\t%s\t%d\t",p.grade,p.name,p.data);
printf("%d—%d—%d\t",p.year,p.month,p.day);
printf("%s\t%d:%d:%d\n",p.week,p.hour,p.minute,p.second);
}
if(q.data!=0)
{
printf("\t%s\t%s\t%d\t",q.grade,q.name,q.data);
printf("%d—%d—%d\t",q.year,q.month,q.day);
printf("%s\t%d:%d:%d\n",q.week,q.hour,q.minute,q.second);
}
if(r.data!=0)
{
printf("\t%s\t%s\t%d\t",r.grade,r.name,r.data);
printf("%d—%d—%d\t",r.year,r.month,r.day);
printf("%s\t%d:%d:%d\n",r.week,r.hour,r.minute,r.second);
}
if(p.data==0)
printf("\t初级暂无最高分信息!\n");
if(q.data==0)
printf("\t中级暂无最高分信息!\n");
if(r.data==0)
printf("\t高级暂无最高分信息!\n");

//重置最佳排行榜
if(p.data!=0&&q.data!=0&&r.data!=0)
{
printf("\t是否重置最佳排行?\n");
printf("\t1:是\t2:否\t");
i=0;
scanf("%d",&i);
if(i==1)
{
p.data=0;
q.data=0;
r.data=0;
if((fp=fopen("tiptop1.txt","w"))==NULL)
{
printf("打开tiptop1.txt文件失败!");
exit(1);
}
fwrite(&p,sizeof(struct tiptop),1,fp);
fclose(fp);
if((fp=fopen("tiptop2.txt","w"))==NULL)
{
printf("打开tiptop2.txt文件失败!");
exit(1);
}
fwrite(&q,sizeof(struct tiptop),1,fp);
fclose(fp);
if((fp=fopen("tiptop3.txt","w"))==NULL)
{
printf("打开tiptop3.txt文件失败!");
exit(1);
}
fwrite(&r,sizeof(struct tiptop),1,fp);
fclose(fp);
}
}
}
}

4.game.c
#include"record.h"

//全局变量
int *c1; //产生的数保存在指针c中
int A,B; // AB均为游戏重要参数
int N; //NUM为需要猜测的数据个数
int TIME; //TIME为猜数字共有的次数
long int S; //S为游戏积分
//****************
//开始游戏中心函数
//****************
void Game_main()
{
FILE *fp;
int time;
if((fp=fopen("C.txt","r"))==NULL)
{
printf("打开C.txt文件失败!");
printf("\n");
exit(1);
}
fread(&C,sizeof(int),1,fp);
N=C+2;
TIME=11-C;
if(C==1)
{
printf("\t游戏等级为:初级!\n");
}
if(C==2)
{
printf("\t游戏等级为:中级!\n");
}
if(C==3)
{
printf("\t游戏等级为:高级!\n");
}
printf("\t需要猜测的数字位数数为:%d，共有%d次猜测机会!",N,TIME);
printf("\n");
time=Time_command();
Game_result(time);
}
//********************
//获取系统随机数字函数
//********************
int *Build_number()
{
int i,j,m;
time_t t;
c1=(int *)malloc(N*sizeof(int));
if(c1==NULL)
{
printf("分配内存错误!\n");
printf("\n");
exit(1);
}
srand((unsigned) time(&t));
for(i=0;i<N;i++)
{
m=rand()%10; //产生一个数字
if(i==0)
*c1=m;
else
{
for(j=0;j<i;j++)
{
if(m==*(c1+j)//若原有数据之中已经有了与m相同的数字，则重新产生数字
{
i--;
break;
}
*(c1+i)=m;
}
}
}
printf("\t系统产生的数据为:");
for(i=0;i<N;i++)
printf("*");
printf("\n");
printf("\t您可以开始游戏! 计时开始...\n");
printf("\t不能有重复的数字!\n");
printf("\t数字中间用空格隔开\n");
return c1;
}
//****************************************
//获取游戏者游戏数据和输出游戏进程结果函数
//****************************************
void Game_in_out()
{
int i,j,m;
int n; //游戏者猜测的数字
int a[5]; //游戏者猜测的数据构成的数组
int c[5];
int *p;
p=Build_number();
for(i=0;i<N;i++)
{
c[i]=*(p+i);
}
for(m=0;m<TIME;m++)
{
if(m==(TIME-1))
{
printf("\t**请注意:**\n");
printf("\t**仅剩下一次机会了!**\n");
printf("\t**努力!加油!**\n");
}
printf("\t请输入第%d次猜测的数字:\t",m+1);
for(j=0;j<N;j++)
{
scanf("%d",&n);
a[j]=n;
}
A=0;
B=0;
for(i=0;i<N;i++)
{
if(a[i]==c[i])
A++;
}
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
if(a[i]==c[j]&&i!=j)
B++;
}
}
printf("\t您本次猜测的结果为：\t");
printf("%d A %d B",A,B);
printf("\n");
//游戏成功控制退出猜测程序
if(A==N)
{
m=TIME;
}
}

//TIME改变，记录游戏总次数的数据
TIME=i;
free(c1);
}
//************
//时间控制函数
//************
int Time_command()
{
int a; //游戏时间
time_t first, second;
first=time(NULL); //获取系统时间
Game_in_out();
second=time(NULL); //再次获取系统时间
a=(int)difftime(second,first);
return a;
}
//********************
//游戏结果处理输出函数
//********************
void Game_result(int m)
{
FILE *fp;
tiptop p;
time_t t;
int S;
int n;
int i=0;
int minute,second;
if(A!=N)
{
S=0;
printf("\tGame over!\n");
printf("\t您本次游戏的积分为：\t%d",S);
printf("\t继续努力!\n");
printf("\t是否继续游戏?\n");
printf("\t1:是\t\t\t2:否");
printf("\n");
scanf("%d",&i);
if(i==1)
Game_main();
else
Menu_select();
}
else
{
printf("\t恭喜您游戏成功!");
printf("\n");
minute=m/60;
second=m%60;
printf("\t您本次游戏所用时间为：");
printf("%d分钟%d秒\n",minute,second);
printf("\n");

//积分
if(C==1)
{
n=11-TIME;
S=n*n*n*10-m;
}
if(C==2)
{
n=10-TIME;
S=n*n*n*n*10-m;
}
if(C==3)
{
n=9-TIME;
S=n*n*n*n*n*10-m;
}
if(S<10)
{
srand((unsigned) time(&t));
S=rand()%100;
}
printf("\t您本次游戏的积分为：\t%d",S);
printf("\n");
}
//判断是否符合最高分条件
if(C==1)
{
if((fp=fopen("tiptop1.txt","r"))==NULL)
{
printf("打开tiptop1.txt文件失败!");
printf("\n");
exit(1);
}
fread(&p,sizeof(struct tiptop),1,fp);
fclose(fp);
}
if(C==2)
{
if((fp=fopen("tiptop2.txt","r"))==NULL)
{
printf("打开tiptop2.txt文件失败!");
printf("\n");
exit(1);
}
fread(&p,sizeof(struct tiptop),1,fp);
fclose(fp);
}
if(C==3)
{
if((fp=fopen("tiptop3.txt","r"))==NULL)
{
printf("打开tiptop3.txt文件失败!");
printf("\n");
exit(1);
}
fread(&p,sizeof(struct tiptop),1,fp);
fclose(fp);
}
if(S>=(p.data))
Tiptop_record(S);
//提示跳转
if(C==1)
{
printf("\t您本次游戏等级是初级，是否要进入中级?\n");
printf("\t1:是\t\t\t2:否");
printf("\n\t");
i=0;
scanf("%d",&i);
if(i==1)
{
C=2;
if((fp=fopen("C.txt","w"))==NULL)
{
printf("打开C.txt文件失败!");
exit(1);
}
fwrite(&C,sizeof(int),1,fp);
fclose(fp);
Game_main();
}
else
Menu_select();
}
if(C==2)
{
printf("\t您本次是中级游戏，是否要进入高级游戏呢?\n");
printf("\t1:是\t\t\t2:否");
printf("\n\t");
i=0;
scanf("%d",&i);
if(i==1)
{
C=3;
if((fp=fopen("C.txt","w"))==NULL)
{
printf("打开C.txt文件失败!");
exit(1);
}
fwrite(&C,sizeof(int),1,fp);
fclose(fp);
Game_main();
}
else
Menu_select();
}
}

5.record.c
#include"record.h"
//******
//主函数
//******
void main()
{
printf("\n");
printf("********************************************\n");
printf("********************************************\n");
printf(" 欢迎进入猜数字游戏 \n");
printf("\n");
printf("\t设计者： \n");
printf("********************************************\n");
printf("********************************************\n");
printf("\n");
Menu_select();
}
//************
//选择菜单函数
//************
void Menu_select()
{
while(1)
{
switch(manage_menu())
{
case 0:
printf("输入有误，请重新输入!\n");
break;
case 1:
Game_main();
break;
case 2:
Game_rank();
break;
case 3:
Tiptop_output();
break;
case 4:
Game_explain();
break;
case 5:
printf("\n");
printf("\n");
printf("*************** ** ** **** ** ** ** ** *** \n");
printf("*************** ** ** ** ** **** ** ** ** ***** \n");
printf(" ** ** ** ** ** ** ** ** ** ** ******* \n");
printf(" ** ** ** ** ** ** ** ** ** ** ******* \n");
printf(" ** *********** ************* ** ** ** **** ***** \n");
printf(" ** *********** ************* ** ** ** **** ***** \n");
printf(" ** ** ** ** ** ** ** ** ** ** ***** \n");
printf(" ** ** ** ** ** ** ** ** ** ** *** \n");
printf(" ** ** ** ** ** ** **** ** ** *** \n");
printf(" ** ** ** ** ** ** ** ** ** *** \n");
printf("\n");
printf("Goodbye!\n");
exit(1);
}
}
}
//************
//处理菜单函数
//************
int manage_menu()
{
int n;
printf("\t**************************\n");
printf("\t**\t1:开始游戏\t**\n");
printf("\t**\t2:等级设置\t**\n");
printf("\t**\t3:最佳排行\t**\n");
printf("\t**\t4:游戏说明\t**\n");
printf("\t**\t5:退出游戏\t**\n");
printf("\t**************************\n");
printf("\t请输入相应序号选择相应菜单:");
printf("\t");
scanf("%d",&n);
printf("\n");
if(n<1||n>5)
n=0;
return n;
}

‘柒’ C语言课程设计

/******头文件（.h）***********/
#include "stdio.h" /*I/O函数*/
#include "stdlib.h" /*标准库函数*/
#include "string.h"/*字符串函数*/
#include "ctype.h" /*字符操作函数*/
#include "conio.h" /*控制台输入输出函数 */
#define M 50 /*定义常数表示记录数*/
typedef struct /*定义数据结构*/
{
char name[20]; /*姓名*/
char units[30]; /*单位*/
char tele[20]; /*电话*/
char m_ph[20]; //手机
char rela[20]; //关系
char email[50]; //邮箱
char qq[20]; //qq
}ADDRESS;
/******以下是函数原型*******/
int enter(ADDRESS t[]); /*输入记录*/
void list(ADDRESS t[],int n); /*显示记录*/
void search(ADDRESS t[],int n); /*按姓名查找显示记录*/
int Delete(ADDRESS t[],int n); /*删除记录*/
int add(ADDRESS t[],int n); /*插入记录*/
void save(ADDRESS t[],int n); /*记录保存为文件*/
int load(ADDRESS t[]); /*从文件中读记录*/
void display(ADDRESS t[]); /*按序号查找显示记录*/
void sort(ADDRESS t[],int n); /*按姓名排序*/
void qseek(ADDRESS t[],int n); /*快速查找记录*/
void print(ADDRESS temp); /*显示单条记录*/
int find(ADDRESS t[],int n,char *s) ; /*查找函数*/
int menu_select(); /*主菜单函数*/
/******主函数开始*******/
main()
{
system("color 37");//背景色为浅绿，前景色为白色
printf(" 欢迎使用通讯录管理系统\n");//欢迎界面
int i;
ADDRESS adr[M]; /*定义结构体数组*/
int length; /*保存记录长度*/
for(;;)/*无限循环*/
{
switch(menu_select()) /*调用主菜单函数，返回值整数作开关语句的条件*/
{
case 0:length=enter(adr);break;/*输入记录*/
case 1:list(adr,length);break; /*显示全部记录*/
case 2:search(adr,length);break; /*查找记录*/
case 3:length=Delete(adr,length);break; /*删除记录*/
case 4:length=add(adr,length); break; /*插入记录*/
case 5:save(adr,length);break; /*保存文件*/
case 6:length=load(adr); break; /*读文件*/
case 7:display(adr);break; /*按序号显示记录*/
case 8:sort(adr,length);break; /*按姓名排序*/
case 9:qseek(adr,length);break; /*快速查找记录*/
case 10:exit(0); /*如返回值为10则程序结束*/
}
}
}
/*菜单函数，函数返回值为整数，代表所选的菜单项*/
int menu_select()
{
char s[80];
int c;
printf("按任意键进入菜单......\n");/*提示按任意键继续*/
getch(); /*读入任意字符*/
system("cls"); /*清屏*/
printf(" ********************菜单***********************\n\n");
printf(" 0. 输入记录\n");
printf(" 1. 显示所有记录\n");
printf(" 2. 按姓名查找记录\n");
printf(" 3. 删除记录\n");
printf(" 4. 添加记录\n");
printf(" 5. 保存文件\n");
printf(" 6. 载入文件\n");
printf(" 7. 按序号显示记录\n");
printf(" 8. 记录排序\n");
printf(" 9. 查找记录\n");
printf(" 10. 退出\n");
printf(" ***********************************************\n");
do
{
printf("\n 请输入选项(0~10):"); /*提示输入选项*/
scanf("%d",&c);/*输入选择项*/
fflush(stdin);
}while(c<0 || c>10);/*选择项不在0~10之间重输*/
return c; /*返回选择项，主程序根据该数调用相应的函数*/
}
/***输入记录，形参为结构体数组，函数值返回类型为整型表示记录长度*/
int enter(ADDRESS t[])
{
int i,n;
char num[30];
system("cls"); /*清屏*/
int flag=1;
for(;;)
{
flag = 1;
system("cls"); /*清屏*/
printf("\n请输入记录数：\n"); /*提示信息*/
scanf("%s", &num); /*输入记录数*/
fflush(stdin);
for(int nima = 0; num[nima]; nima++)
{
if (num[nima] < 48 || num[nima] > 57)
{
flag = 0;
break;
}
}
if(flag==1)
break;
}
n=atoi(num);
printf("请输入记录：\n"); /*提示输入记录*/
printf("姓名单位电话手机关系邮箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
for(i=0;i<n;i++)
{
scanf("%s%s%s%s%s%s%s",t[i].name,t[i].units,t[i].tele,t[i].m_ph,t[i].rela,t[i].email,t[i].qq); /*输入记录*/
fflush(stdin);
for(int k=0;k<=19;k++)
{
if((t[i].tele[k]>='a' && t[i].tele[k]<='z' )|| (t[i].tele[k]>='A' && t[i].tele[k]<='Z'))
{
printf("电话输入错误！请重新输入联系人信息\n");
i--;
break;
}
if((t[i].m_ph[k]>='a' && t[i].m_ph[k]<='z' )|| (t[i].m_ph[k]>='A' && t[i].m_ph[k]<='Z'))
{
printf("手机输入错误！请重新输入联系人信息\n");
i--;
break;
}
if((t[i].qq[k]>='a' && t[i].qq[k]<='z' )|| (t[i].qq[k]>='A' && t[i].qq[k]<='Z'))
{
printf("QQ输入错误！请重新输入联系人信息\n");
i--;
break;
}
}
printf("--------------------------------------------------------------------------\n");
}
return n; /*返回记录条数*/
}
/*显示记录，参数为记录数组和记录条数*/
void list(ADDRESS t[],int n)
{
int i;
system("cls"); /*清屏*/
printf("\n\n************************************************************************\n");
printf("姓名单位电话手机关系邮箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
for(i=0;i<n;i++)
printf("%-10s%-14s%-12s%-12s%-10s%-12s%-14s\n",t[i].name,t[i].units,t[i].tele,t[i].m_ph,t[i].rela,t[i].email,t[i].qq);
if((i+1)%10==0) /*判断输出是否达到10条记录*/
{
printf("按任意键显示下一页\n"); /*提示信息*/
getch(); /*按任意键继续*/

}
printf("*********************************结束***********************************\n");
}
/*查找记录*/
void search(ADDRESS t[],int n)
{
char s[20]; /*保存待查找姓名字符串*/
int i; /*保存查找到结点的序号*/
system("cls"); /*清屏*/
printf("请输入待查找姓名：\n");
scanf("%s",s); /*输入待查找姓名*/
i=find(t,n,s); /*调用find函数，得到一个整数*/
if(i>n-1) /*如果整数i值大于n-1，说明没找到*/
{
printf("未找到!!!\n");
getch();
}
else
print(t[i]); /*找到，调用显示函数显示记录*/
}
/*显示指定的一条记录*/
void print(ADDRESS temp)
{
system("cls"); /*清屏*/
printf("\n\n************************************************************************\n");
printf("姓名单位电话手机关系邮箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
printf("%-10s%-14s%-12s%-12s%-10s%-12s%-14s\n",temp.name,temp.units,temp.tele,temp.m_ph,temp.rela,temp.email,temp.qq);
printf("*********************************结束***********************************\n");
getchar();
}
/*查找函数，参数为记录数组和记录条数以及姓名s */
int find(ADDRESS t[],int n,char *s)
{
int i;
system("cls"); /*清屏*/
for(i=0;i<n;i++)/*从第一条记录开始，直到最后一条*/
{
if(strcmp(s,t[i].name)==0) /*记录中的姓名和待比较的姓名是否相等*/
return i; /*相等，则返回该记录的下标号，程序提前结结束*/
}
return i; /*返回i值*/
getch();
}
/*删除函数，参数为记录数组和记录条数*/
int Delete(ADDRESS t[],int n)
{
char s[20]; /*要删除记录的姓名*/
char ch;
int i,j;
system("cls"); /*清屏*/
printf("请输入待删除的姓名：\n"); /*提示信息*/
scanf("%s",s);/*输入姓名*/
i=find(t,n,s); /*调用find函数*/
if(i>n-1) /*如果i>n-1超过了数组的长度*/
printf("未找到!!!\n"); /*显示没找到要删除的记录*/
else
{
print(t[i]); /*调用输出函数显示该条记录信息*/
printf("确定删除？(Y/N)\n"); /*确认是否要删除*/
scanf("%c",&ch); /*输入一个整数0或1*/
if(ch=='y' || ch=='Y') /*如果确认删除输入y*/
{
for(j=i+1;j<n;j++) /*删除该记录，实际后续记录前移*/
{
strcpy(t[j-1].name,t[j].name); /*将后一条记录的姓名拷贝到前一条*/
strcpy(t[j-1].units,t[j].units); /*将后一条记录的单位拷贝到前一条*/
strcpy(t[j-1].tele,t[j].tele); /*将后一条记录的电话拷贝到前一条*/
strcpy(t[j-1].m_ph,t[j].m_ph); /*将后一条记录的手机拷贝到前一条*/
strcpy(t[j-1].rela,t[j].rela); /*将后一条记录的关系拷贝到前一条*/
strcpy(t[j-1].email,t[j].email); /*将后一条记录的邮箱拷贝到前一条*/
strcpy(t[j-1].qq,t[j].qq); /*将后一条记录的qq拷贝到前一条*/
}
printf("删除成功！\n");
n--; /*记录数减1*/
}
}
getch();
return n; /*返回记录数*/
}
/*插入记录函数，参数为结构体数组和记录数*/
int add(ADDRESS t[],int n)/*插入函数，参数为结构体数组和记录数*/
{
ADDRESS temp; /*新插入记录信息*/
int i,j,flag;
char s[30]; /*确定插入在哪个记录之前*/
system("cls"); /*清屏*/
printf("请输入记录：\n");
printf("************************************************************************\n");
printf("姓名单位电话手机关系邮箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
scanf("%s%s%s%s%s%s%s",temp.name,temp.units,temp.tele,temp.m_ph,temp.rela,temp.email,temp.qq); /*输入插入信息*/
fflush(stdin);
printf("请输入插入位置的姓名： \n");
scanf("%s",s); /*输入插入位置的姓名*/
i=find(t,n,s); /*调用find，确定插入位置*/
for(j=n-1;j>=i;j--) /*从最后一个结点开始向后移动一条*/
{
strcpy(t[j+1].name,t[j].name); /*当前记录的姓名拷贝到后一条*/
strcpy(t[j+1].units,t[j].units); /*当前记录的单位拷贝到后一条*/
strcpy(t[j+1].tele,t[j].tele); /*当前记录的电话拷贝到后一条*/
strcpy(t[j+1].m_ph,t[j].m_ph); /*当前记录的手机拷贝到后一条*/
strcpy(t[j+1].rela,t[j].rela); /*当前记录的关系拷贝到后一条*/
strcpy(t[j+1].email,t[j].email); /*当前记录的邮箱拷贝到后一条*/
strcpy(t[j+1].qq,t[j].qq); /*当前记录的qq拷贝到后一条*/
}
strcpy(t[i].name,temp.name); /*将新插入记录的姓名拷贝到第i个位置*/
strcpy(t[i].units,temp.units); /*将新插入记录的单位拷贝到第i个位置*/
strcpy(t[i].tele,temp.tele); /*将新插入记录的电话拷贝到第i个位置*/
strcpy(t[i].m_ph,temp.m_ph); /*将新插入记录的手机拷贝到第i个位置*/
strcpy(t[i].rela,temp.rela); /*将新插入记录的关系拷贝到第i个位置*/
strcpy(t[i].email,temp.email); /*将新插入记录的邮箱拷贝到第i个位置*/
strcpy(t[i].qq,temp.qq); /*将新插入记录的qq拷贝到第i个位置*/
n++; /*记录数加1*/
printf("添加成功!!!\n");
getch();
return n; /*返回记录数*/
}
/*保存函数，参数为结构体数组和记录数*/
void save(ADDRESS t[],int n)
{
int i;
char outfile[30];
FILE *fp; /*指向文件的指针*/
system("cls"); /*清屏*/
printf("请输入待保存的文件名：\n");
scanf("%s",outfile);
if((fp=fopen(outfile,"wb"))==NULL) /*打开文件，并判断打开是否正常*/
{
printf("无法打开文件！\n");/*无法打开*/
exit(1); /*退出*/
}
printf("\n保存文件...\n"); /*输出提示信息*/
fprintf(fp,"%d",n); /*将记录数写入文件*/
fprintf(fp,"\r\n"); /*将换行符号写入文件*/
for(i=0;i<n;i++)
{
fprintf(fp,"%-10s%-14s%-12s%-12s%-10s%-12s%-14s\n",t[i].name,t[i].units,t[i].tele,t[i].m_ph,t[i].rela,t[i].email,t[i].qq);/*格式写入记录*/
fprintf(fp,"\r\n"); /*将换行符号写入文件*/
}
fclose(fp);/*关闭文件*/
printf("****保存成功！****\n"); /*显示保存成功*/
getch();
}
/*载入函数，参数为结构体数组*/
int load(ADDRESS t[])
{
int i,n;
char outfile[30];
FILE *fp; /*指向文件的指针*/
system("cls"); /*清屏*/
printf("请输入待载入的文件名：\n");
scanf("%s",outfile);
if((fp=fopen(outfile,"rb"))==NULL)/*打开文件*/
{
printf("无法打开文件！\n"); /*不能打开*/
exit(1); /*退出*/
}
fscanf(fp,"%d",&n); /*读入记录数*/
for(i=0;i<n;i++)
fscanf(fp,"%10s%14s%12s%12s%10s%12s%14s",t[i].name,t[i].units,t[i].tele,
t[i].m_ph,t[i].rela,t[i].email,t[i].qq); /*按格式读入记录*/
fclose(fp); /*关闭文件*/
printf("从文件读入数据成功!!!\n"); /*显示保存成功*/
getch();
return n; /*返回记录数*/

}
/*按序号显示记录函数*/
void display(ADDRESS t[])
{
int id,n;
char outfile[30];
FILE *fp; /*指向文件的指针*/
system("cls"); /*清屏*/
printf("请输入待载入的文件名：");
scanf("%s",outfile);
if((fp=fopen(outfile,"rb"))==NULL) /*打开文件*/
{
printf("无法打开文件！\n"); /*不能打开文件*/
exit(1); /*退出*/
}
printf("请输入记录序号：\n"); /*显示信息*/
scanf("%d",&id); /*输入序号*/
fscanf(fp,"%d",&n); /*从文件读入记录数*/
if(id>=0&&id<n) /*判断序号是否在记录范围内*/
{
fseek(fp,(id-1)*sizeof(ADDRESS),1); /*移动文件指针到该记录位置*/
print(t[id]); /*调用输出函数显示该记录*/
printf("\r\n");
}
else
{
printf(" %d号记录不存在!!!\n ",id); /*如果序号不合理显示信息*/
getch();
}
fclose(fp); /*关闭文件*/
}
/*排序函数，参数为结构体数组和记录数*/
void sort(ADDRESS t[],int n)
{
int i,j,flag;
system("cls"); /*清屏*/
ADDRESS temp; /*临时变量做交换数据用*/
for(i=0;i<n;i++)
{
flag=0; /*设标志判断是否发生过交换*/
for(j=0;j<n-1;j++)
if((strcmp(t[j].name,t[j+1].name))>0) /*比较大小*/
{
flag=1;
strcpy(temp.name,t[j].name); /*交换记录*/
strcpy(temp.units,t[j].units);
strcpy(temp.tele,t[j].tele);
strcpy(temp.m_ph,t[j].m_ph);
strcpy(temp.rela,t[j].rela);
strcpy(temp.email,t[j].email);
strcpy(temp.qq,t[j].qq);

strcpy(t[j].name,t[j+1].name);
strcpy(t[j].units,t[j+1].units);
strcpy(t[j].tele,t[j+1].tele);
strcpy(t[j].m_ph,t[j+1].m_ph);
strcpy(t[j].rela,t[j+1].rela);
strcpy(t[j].email,t[j+1].email);
strcpy(t[j].qq,t[j+1].qq);

strcpy(t[j+1].name,temp.name);
strcpy(t[j+1].units,temp.units);
strcpy(t[j+1].tele,temp.tele);
strcpy(t[j+1].m_ph,temp.m_ph);
strcpy(t[j+1].rela,temp.rela);
strcpy(t[j+1].email,temp.email);
strcpy(t[j+1].qq,temp.qq);
}
if(flag==0)break; /*如果标志为0，说明没有发生过交换循环结束*/
}
printf("排序成功!!!\n"); /*显示排序成功*/
}
/*快速查找，参数为结构体数组和记录数*/
void qseek(ADDRESS t[],int n)
{
char s[20];
int l,r,m;
system("cls"); /*清屏*/
printf("\n请在查找前排序!\n"); /*提示确认在查找之前，记录是否已排序*/
printf("请输入待查找的姓名：\n"); /*提示输入*/
scanf("%s",s); /*输入待查找的姓名*/
l=0;r=n-1; /*设置左边界与右边界的初值*/
while(l<=r) /*当左边界<=右边界时*/
{
m=(l+r)/2; /*计算中间位置*/
if(strcmp(t[m].name,s)==0) /*与中间结点姓名字段做比较判是否相等*/
{
print(t[m]); /*如果相等，则调用print函数显示记录信息*/
return ; /*返回*/
}
if(strcmp(t[m].name,s)<0) /*如果中间结点小*/
l=m+1; /*修改左边界*/
else
r=m-1; /*否则，中间结点大，修改右边界*/
}
if(l>r) /*如果左边界大于右边界时*/
printf("未找到！\n"); /*显示没找到*/
getch();
}

‘捌’ C语言课程设计报告中的数据结构是什么

数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。

其实在计算机专业，《数据结构》是一门课程，主要就学些链表、堆栈、二叉树等及一些排序、查找等算法等。比较好的教材是清华大学严蔚敏主编的《数据结构》，网上也有很多视频，不妨去看看。

‘玖’ C语言课程设计

已调通，大致功能相当
#include <stdio.h>
#include <stdlib.h> /*其它说明*/
#include <string.h> /*字符串函数*/
#include <time.h>

#define LEN sizeof(STUDENT)
typedef struct stu /*定义结构体数组用于缓存数据*/
{
char num[6];
char name[5];
int score[3];
int sum;
float average;
int order;
struct stu *next;
}STUDENT;

/*初始化函数*/
STUDENT *Init()
{
return NULL; /*返回空指针*/
}

/*菜单选择函数*/
int Menu_Select()
{
int n;
struct tm *pt; /*定义时间结构体*/
time_t t;

t=time(NULL);
pt=localtime(&t); /*读取系统日期并把它放到结构体中*/
printf("\n按任一键进入主菜单...... \n"); /*按任一键进入主菜单*/
//getch(); /*从键盘读取一个字符,但不显示于屏幕*/
system("pause");
system("cls"); /*清屏*/
printf("********************************************************************************\n");
printf("\t\t 欢迎 Welcome to\n");
printf("\n\t\t\t 使用学生管理系统1.0\n");
printf("*************************************MENU***************************************\n");
printf("\t\t\t1. 输入学生成绩记录 Enter the record\n"); /*输入学生成绩记录*/
printf("\t\t\t2. 显示 Print the record\n"); /*显示*/
printf("\t\t\t3. 寻找 Search record on name\n"); /*寻找*/
printf("\t\t\t4. 删除 Delete a record\n"); /*删除*/
printf("\t\t\t5. 排序 Sort to make New a file\n"); /*排序*/
printf("\t\t\t6. 插入 Insert record to list\n"); /*插入*/
printf("\t\t\t7. 保存 Save the file\n"); /*保存*/
printf("\t\t\t8. 读取 Load the file\n"); /*读取*/
printf("\t\t\t9. 退出 Quit\n"); /*退出*/
printf("\n********************************************************************************\n");
printf("\t\t\t\t当前系统日期:%d-%d-%d\n",pt->tm_year+1900,pt->tm_mon+1,pt->tm_mday); /*显示当前系统日期*/
do
{
printf("\n\t\t\t输入你的选择Enter your choice(1~9):");
fflush(stdin);
scanf("%d",&n);
}while(n<1||n>9); /*如果选择项不在1~9之间则重输*/
return(n); /*返回选择项，主函数根据该数调用相应的函数*/
}

/*输入函数*/
STUDENT *Create()
{
int i,s;
STUDENT *head=NULL,*p; /* 定义函数.此函数带回一个指向链表头的指针*/
system("cls");
for(;;)
{
p=(STUDENT *)malloc(LEN); /*开辟一个新的单元*/
if(!p) /*如果指针p为空*/
{
printf("\n输出内存溢出. Out of memory."); /*输出内存溢出*/
return (head); /*返回头指针,下同*/
}
printf("输入学号Enter the num(0:list end):");
scanf("%s",p->num);
if(p->num[0]=='0') break; /*如果学号首字符为0则结束输入*/
printf("输入名字Enter the name:");
scanf("%s",p->name);
printf("请输入3门成绩Please enter the %d scores\n",3); /*提示开始输入成绩*/
s=0; /*计算每个学生的总分，初值为0*/
for(i=0;i<3;i++) /*3门课程循环3次*/
{
do
{
printf("成绩score%d:",i+1);
scanf("%d",&p->score[i]);
if(p->score[i]<0 || p->score[i]>100) /*确保成绩在0~100之间*/
printf("数据错误,请重新输入 Data error,please enter again.\n");
}while(p->score[i]<0 || p->score[i]>100);
s=s+p->score[i]; /*累加各门成绩*/
}
p->sum=s; /*将总分保存*/
p->average=(float)s/3; /*先用强制类型转换将s转换成float型,再求平均值*/
p->order=0; /*未排序前此值为0*/
p->next=head; /*将头结点做为新输入结点的后继结点*/
head=p; /*新输入结点为新的头结点*/
}
return(head);
}

/* 显示全部记录函数*/
void Print(STUDENT *head)
{
int i=0; /* 统计记录条数*/
STUDENT *p; /*移动指针*/
system("cls");
p=head; /*初值为头指针*/
printf("\n************************************STUDENT************************************\n");
printf("-------------------------------------------------------------------------------\n");
printf("| Rec | Num | Name | Sc1 | Sc2 | Sc3 | Sum | Ave | Order |\n");
printf("-------------------------------------------------------------------------------\n");
while(p!=NULL)
{
i++;
printf("| %3d | %4s | %-4s | %3d | %3d | %3d | %3d | %4.2f | %-5d|\n",
i, p->num,p->name,p->score[0],p->score[1],p->score[2],p->sum,p->average,p->order);
p=p->next;
}
printf("-------------------------------------------------------------------------------\n");
printf("**************************************END**************************************\n");
}

/*查找记录函数*/
void Search(STUDENT *head)
{
STUDENT *p; /* 移动指针*/
char s[5]; /*存放姓名用的字符数组*/
system("cls");
printf("请输入个姓名来查找. Please enter name for searching.\n");
scanf("%s",s);
p=head; /*将头指针赋给p*/
while(strcmp(p->name,s) && p != NULL) /*当记录的姓名不是要找的，或指针不为空时*/
p=p->next; /*移动指针，指向下一结点*/
if(p!=NULL) /*如果指针不为空*/
{
printf("\n*************************************FOUND************************************\n");
printf("-------------------------------------------------------------------------------\n");
printf("| Num | Name | sc1 | sc2 | sc3 | Sum | Ave | Order |\n");
printf("-------------------------------------------------------------------------------\n");
printf("| %4s | %4s | %3d | %3d | %3d | %3d | %4.2f | %-5d|\n",
p->num,p->name,p->score[0],p->score[1],p->score[2],p->sum,p->average,p->order);
printf("-------------------------------------------------------------------------------\n");
printf("***************************************END**************************************\n");
}
else
printf("\n没有该学生 There is no num %s student on the list.\n",s); /*显示没有该学生*/
}

/*删除记录函数*/
STUDENT *Delete(STUDENT *head)
{
//int n;
STUDENT *p1,*p2; /*p1为查找到要删除的结点指针，p2为其前驱指针*/
char c,s[6]; /*s[6]用来存放学号,c用来输入字母*/
system("cls");
printf("请输入要删除的学号 Please enter the Deleted num: ");
scanf("%s",s);
p1=p2=head; /*给p1和p2赋初值头指针*/
while(strcmp(p1->num,s) && p1 != NULL) /*当记录的学号不是要找的，或指针不为空时*/
{
p2=p1; /*将p1指针值赋给p2作为p1的前驱指针*/
p1=p1->next; /*将p1指针指向下一条记录*/
}
if(strcmp(p1->num,s)==0) /*学号找到了*/
{
printf("**************************************FOUND************************************\n");
printf("-------------------------------------------------------------------------------\n");
printf("| Num | Name | sc1 | sc2 | sc3 | Sum | Ave | Order |\n");
printf("-------------------------------------------------------------------------------\n");
printf("| %4s | %4s | %3d | %3d | %3d | %3d | %4.2f | %-5d|\n",
p1->num,p1->name,p1->score[0],p1->score[1],p1->score[2],p1->sum,p1->average,p1->order);
printf("-------------------------------------------------------------------------------\n");
printf("***************************************END**************************************\n");
printf("\n是否要删除,输入Y删除,N则退出\nAre you sure to Delete the student Y/N ?"); /*提示是否要删除,输入Y删除,N则退出*/
for(;;)
{
scanf("%c",&c);
if(c=='n'||c=='N') break; /*如果不删除,则跳出本循环*/
if(c=='y'||c=='Y')
{
if(p1==head) /*若p1==head，说明被删结点是首结点*/
head=p1->next; /*把第二个结点地址赋予head*/
else
p2->next=p1->next; /*否则将一下结点地址赋给前一结点地址*/
//n=n-1;
printf("\n学号为(Num): %s 学生以被删除(student have been Deleted.)\n",s);
printf("别忘了保存. Don't forget to Save.\n");break; /*删除后就跳出循环*/
}
}
}
else
printf("\n没有这个学生在表上\nThere is no num %s student on the list.\n",s); /*找不到该结点*/
return(head);
}

/*排序函数*/
STUDENT *Sort(STUDENT *head)
{
int i=0; /*保存名次*/
STUDENT *p1,*p2,*t,*temp; /*定义临时指针*/
temp=head->next; /*将原表的头指针所指的下一个结点作头指针*/
head->next=NULL; /*第一个结点为新表的头结点*/
while(temp!=NULL) /*当原表不为空时，进行排序*/
{
t=temp; /*取原表的头结点*/
temp=temp->next; /*原表头结点指针后移*/
p1=head; /*设定移动指针p1，从头指针开始*/
p2=head; /*设定移动指针p2做为p1的前驱，初值为头指针*/
while(t->average<p1->average&&p1!=NULL) /*作成绩平均分比较*/
{
p2=p1; /*待排序点值小，则新表指针后移*/
p1=p1->next;
}
if(p1==p2) /*p1==p2，说明待排序点值大，应排在首位*/
{
t->next=p1; /*待排序点的后继为p*/
head=t; /*新头结点为待排序点*/
}
else /*待排序点应插入在中间某个位置p2和p1之间，如p为空则是尾部*/
{
t->next=p1; /*t的后继是p1*/
p2->next=t; /*p2的后继是t*/
}
}
p1=head; /*已排好序的头指针赋给p1，准备填写名次*/
while(p1!=NULL) /*当p1不为空时，进行下列操作*/
{
i++; /*结点序号*/
p1->order=i; /*将结点序号赋值给名次*/
p1=p1->next; /*指针后移*/
}
printf("排序成功 Sorting is sucessful.\n"); /*排序成功*/
return (head);
}

/*插入记录函数*/
STUDENT *Insert(STUDENT *head,STUDENT *New)
{
STUDENT *p0,*p1,*p2;
//int n;
int sum1,i;
p1=head; /*使p1指向第一个结点*/
p0=New; /*p0指向要插入的结点*/
printf("\nPlease enter a New record.\n"); /*提示输入记录信息*/
printf("输入学号Enter the num:");
scanf("%s",New->num);
printf("输入名字Enter the name:");
scanf("%s",New->name);
printf("Please enter the %d scores.\n",3);
sum1=0; /*保存新记录的总分，初值为0*/
for(i=0;i<3;i++)
{
do
{
printf("成绩score%d:",i+1);
scanf("%d",&New->score[i]);
if(New->score[i]>100||New->score[i]<0)
printf("数据错误Data error,please enter again.\n");
}while(New->score[i]>100||New->score[i]<0);
sum1=sum1+New->score[i]; /*累加各门成绩*/
}
New->sum=sum1; /*将总分存入新记录中*/
New->average=(float)sum1/3;
New->order=0;
if(head==NULL) /*原来的链表是空表*/
{
head=p0;
p0->next=NULL;
} /*使p0指向的结点作为头结点*/
else
{
while((p0->average<p1->average)&&(p1->next!=NULL))
{
p2=p1; /*使p2指向刚才p1指向的结点*/
p1=p1->next; /*p1后移一个结点*/
}
if(p0->average>=p1->average)
{
if(head==p1)head=p0; /*插到原来第一个结点之前*/
else p2->next=p0; /*插到p2指向的结点之后*/
p0->next=p1;
}
else
{
p1->next=p0;
p0->next=NULL;
} /*插到最后的结点之后*/
}
//n=n+1; /*结点数加1*/
head=Sort(head); /*调用排序的函数,将学生成绩重新排序*/
printf("\n学生Student %s 已被更新have been inserted.\n",New->name);
printf("不要忘了保存Don't forget to Save the New file.\n");
return(head);
}

/*保存数据到文件函数*/
void Save(STUDENT *head)
{
FILE *fp; /*定义指向文件的指针*/
STUDENT *p; /* 定义移动指针*/
char outfile[10];
printf("输出文件例如:c:\\score Enter outfile name,for example c:\\score\n");
scanf("%s",outfile);
if((fp=fopen(outfile,"w"))==NULL) /*为输出打开一个二进制文件,为只写方式*/
{
printf("打不开文件Cannot open the file\n");
return; /*若打不开则返回菜单*/
}
printf("\n保存中...Saving the file......\n");
p=head; /*移动指针从头指针开始*/
while(p!=NULL) /*如p不为空*/
{
fwrite(p,LEN,1,fp); /*写入一条记录*/
p=p->next; /*指针后移*/
}
fclose(fp); /*关闭文件*/
printf("保存成功....Save the file successfully!\n");
}

/* 从文件读数据函数*/
STUDENT *Load()
{
STUDENT *p1,*p2,*head=NULL; /*定义记录指针变量*/
FILE *fp; /* 定义指向文件的指针*/
char infile[10];
printf("倒入文件例如:c:\\score Enter infile name,for example c:\\score\n");
scanf("%s",infile);
if((fp=fopen(infile,"r"))==NULL) /*打开一个二进制文件，为只读方式*/
{
printf("打不开文件Can not open the file.\n");
return(head);
}
printf("\n寻找文件...Loading the file!\n");
p1=(STUDENT *)malloc(LEN); /*开辟一个新单元*/
if(!p1)
{
printf("内存溢出!Out of memory!\n");
return(head);
}
head=p1; /*申请到空间，将其作为头指针*/
while(!feof(fp)) /*循环读数据直到文件尾结束*/
{
if(fread(p1,LEN,1,fp)!=1) break; /*如果没读到数据，跳出循环*/
p1->next=(STUDENT *)malloc(LEN); /*为下一个结点开辟空间*/
if(!p1->next)
{
printf("Out of memory!\n");
return (head);
}
p2=p1; /*使p2指向刚才p1指向的结点*/
p1=p1->next; /*指针后移，新读入数据链到当前表尾*/
}
p2->next=NULL; /*最后一个结点的后继指针为空*/
fclose(fp);
printf("\n你成功的从文件中读取了数据!\nYou have success to read data from the file!\n");
return (head);
}

/*主函数界面*/
int main()
{
STUDENT *head,New;
head=Init(); //链表初始化,使head的值为NULL
for(;;) //循环无限次
{
switch(Menu_Select())
{
case 1:head=Create();break;
case 2:Print(head);break;
case 3:Search(head);break;
case 4:head=Delete(head);break;
case 5:head=Sort(head);break;
case 6:head=Insert(head,&New);break; //&New表示返回地址
case 7:Save(head);break;
case 8:head=Load(); break;
case 9:exit(0); //如菜单返回值为9则程序结束
}
}

return 0;
}

‘拾’ 数据结构C语言版课程设计

创建多项式A:
系数幂次(0 0结束) : 1 0
系数幂次(0 0结束) : 2 1
系数幂次(0 0结束) : 3 2
系数幂次(0 0结束) : 0 0
A(x) = 3.00x^2 + 2.00x + 1.00
创建多项式B:
系数幂次(0 0结束) : 1 4
系数幂次(0 0结束) : -3 2
系数幂次(0 0结束) : 1 1
系数幂次(0 0结束) : -2 0
系数幂次(0 0结束) : 0 0
B(x) = 1.00x^4 - 3.00x^2 + 1.00x - 2.00
C(x) = 3.00x^6 + 2.00x^5 - 8.00x^4 - 3.00x^3 - 7.00x^2 - 3.00x - 2.00
A(2.00) = 17.0000
B(2.00) = 4.0000
C(2.00) = 68.0000
Press any key to continue

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#defineEPS1E-6
typedefstructitem{
doublecoefficient;
intpower;
structitem*next;
}*POLYNOMIAL,*NODE;
POLYNOMIALCreate(){//创建多项式
NODEhead,p;
doublecoe;
intpwr;
head=p=(NODE)malloc(sizeof(item));
while(1){
printf("系数幂次(00结束):");
scanf("%lf%d",&coe,&pwr);
if(coe==0.0&&pwr==0)break;
p->next=(NODE)malloc(sizeof(item));
p->next->coefficient=coe;
p->next->power=pwr;
p=p->next;
}
p->next=NULL;
returnhead;
}
voidSort(POLYNOMIALhead){//按幂次降排序
NODEpt,q,p=head;
while(p->next){
q=p->next;
while(q->next){
if(p->next->power<q->next->power){
pt=p->next;
p->next=q->next;
q->next=p->next->next;
p->next->next=pt;
}
elseq=q->next;
}
p=p->next;
}
}
voidShow(POLYNOMIALhead){//显示多项式
POLYNOMIALp=head->next;
intflag=1;
if(p==NULL)return;
while(p){
if(flag){
if(fabs(p->coefficient)>=EPS){
if(p->power==0)printf("%.2lf",p->coefficient);
elseif(p->power==1)printf("%.2lfx",p->coefficient);
elseprintf("%.2lfx^%d",p->coefficient,p->power);
}
flag=0;
}
elseif(p->coefficient>0){
if(p->power==0)printf("+%.2lf",p->coefficient);
elseif(p->power==1)printf("+%.2lfx",p->coefficient);
elseprintf("+%.2lfx^%d",p->coefficient,p->power);
}
else{
if(p->power==0)printf("-%.2lf",-p->coefficient);
elseif(p->power==1)printf("-%.2lfx",-p->coefficient);
elseprintf("-%.2lfx^%d",-p->coefficient,p->power);
}
p=p->next;
}
printf("
");
}
doublePower(doublex,intn){
doublevalue=1.0;
inti;
for(i=1;i<=n;++i)value*=x;
returnvalue;
}
doubleValue(POLYNOMIALhead,doublex){//多项式求值
POLYNOMIALp;
doublevalue=0.0;
for(p=head->next;p;p=p->next)
value+=p->coefficient*Power(x,p->power);
returnvalue;
}
POLYNOMIALMult(POLYNOMIALA,POLYNOMIALB){//多项式相乘
POLYNOMIALhead,t,p,q;
head=t=(NODE)malloc(sizeof(item));
for(p=A->next;p;p=p->next){//完成相乘过程
for(q=B->next;q;q=q->next){
t->next=(NODE)malloc(sizeof(item));
t->next->coefficient=p->coefficient*q->coefficient;
t->next->power=p->power+q->power;
t=t->next;
}
}
t->next=NULL;
Sort(head);//排序
p=head;
while(p->next){//合并同类项
q=p->next;
while(q->next){
if(p->next->power==q->next->power){
p->next->coefficient+=q->next->coefficient;
t=q->next;
q->next=t->next;
free(t);
}
elseq=q->next;
}
p=p->next;
}
returnhead;
}
voidFreeMemory(POLYNOMIALhead){
POLYNOMIALq,p=head;
while(p){
q=p;
p=q->next;
free(q);
}
}
intmain(){
printf("创建多项式A:
");
POLYNOMIALA=Create();
Sort(A);
printf("A(x)=");Show(A);
printf("创建多项式B:
");
POLYNOMIALB=Create();
Sort(B);
printf("B(x)=");Show(B);
POLYNOMIALC=Mult(A,B);
printf("C(x)=");Show(C);
printf("A(%.2lf)=%.4lf
",2.0,Value(A,2.0));
printf("B(%.2lf)=%.4lf
",2.0,Value(B,2.0));
printf("C(%.2lf)=%.4lf
",2.0,Value(C,2.0));
FreeMemory(A);
FreeMemory(B);
FreeMemory(C);
return0;
}

数据c语言课程设计

与数据c语言课程设计相关的内容