数据结构课程设计学生成绩管理系统.docx

数据结构课程设计学生成绩管理系统.docx

《数据结构课程设计学生成绩管理系统.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计学生成绩管理系统.docx（24页珍藏版）》请在冰豆网上搜索。

数据结构课程设计学生成绩管理系统

课程设计报告

课程设计题目：

1：

学生成绩管理系统

2：

joseph环

3：

猴子选大王

姓名洪军

学号201420180706

班级1421807

指导教师邹国华

2015年12月17日

1：

学生成绩管理系统

1,问题分析；

定义一个学生管理系统实现对学生基本数据的管理，

录入：

输入每位学生的信息；

输出：

输出每位学生的信息；

查询：

可以按3学号和4姓名查询某个学生的信息；

修改：

可以修改学生（按1学号修改，按2成绩修改）的信息；

插入：

可以插入一个学生的信息；

删除：

可以删除（按1学号删除，按2成绩删除）满足条件的学生信息；

排序：

可以按学生的总成绩排序。

2结构分析

首先分析结果我采用的是单链表的存储结构通过此系统可以实现如下功能：

定义一个学生类型student（学号，姓名，四门课程成绩），学生链表student，含有学生数组和学生数。

3实现流程分析

定义数据类型typedefstructstudent

初始化结构体并输入学生的数据inputstu（stu&s,intn）

重载运算符便于输入输出学生的成绩

输出函数输出全部学生的信息output（stus）

查找学生3按学号查找getstu1（stus,chari[]）4按姓名查找getstu2（stus,charc[]）

插入学生insetstu（stu&s,inti,charnu[],charna[],charse[],intsc[]）

1按学号删除学生deletestu1（stu&s），2按姓名删除学生deletestu2（stu&s）

1按学号修改学生的信息update1（stu&s）2按姓名修改学生的信息update2（stu&s）

对总成绩排序sort（stu&s,structshushuzu[]）

CPP文件实现所有功能

4算法实现

头文件status.h

typedefintstatus;

#defineTURE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineOVERFLOW-2

#defineN10

typedefstructstudent{//学生结构体（链表）

charnum[9];

charname[15];

charsex[2];

intscore[4];

student*next;

}student,*stu;

structshu{//辅助结构体数组存储学生总成绩和学号便于排序

floatallscore;

charnum[9];

}shuzu[10];

ostream&operator<<（ostream&os,stu&s）;//运算符的重载

istream&operator>>（istream&is,stu&s）;//运算符的重载

voidinputstu（stu&s,intn）//初始化并且输入函数

{

student*p,*r;

inti;

s=（stu）malloc（sizeof（student））;//申请头节点

r=s;

for（i=0;i

{

p=（student*）malloc（sizeof（student））;//申请链表空间

cin>>p;

r->next=p;

r=p;

}

r->next=NULL;//最后节点指像空

}

statusoutput（stus）//输出函数

{

student*r;

r=s;

r=r->next;

while（r）//判断结点存在

{

cout<

r=r->next;

}

return0;

}

statusgetstu1（stus,chari[]）//按学号查找

{

student*p=s;

while（strcmp（p->num,i）!

=0）//结点的名字相比较

{

p=p->next;

}

if（p）//判断结点存在并且输出

{

cout<

returnTURE;

}

else

returnERROR;

}

statusgetstu2（stus,charc[]）//按名字查找

{

student*p=s->next;

while（strcmp（p->name,c）!

=0）

{

p=p->next;

}

if（p）//判断结点存在并且输出

{cout<

else

returnERROR;

}

statusinsetstu（stu&s,inti,charnu[],charna[],charse[],intsc[]）//插入学生

{

student*p=s,*q;

intj=0,m;

while（jnext）//找到学生的位置

{

p=p->next;

j++;

}

if（j==i-1）

{

q=（student*）malloc（sizeof（student））;//申请新结点

if（!

q）returnOVERFLOW;//申请失败返回错误

{

strcpy（q->name,na）;//赋值

strcpy（q->num,nu）;

for（m=0;m<4;m++）

q->score[m]=sc[m];

strcpy（q->sex,se）;

q->next=p->next;

p->next=q;

returnOK;

}

}

else

returnERROR;

}

statusdeletestu1（stu&s）//按学号删除学生

{

chari[10];

cout<<"请输入你要删除学生的学号"<

cin>>i;

student*p=s,*r;

while（strcmp（p->next->num,i）!

=0）//找到修改学生

{

p=p->next;

}

if（p）//存在就删除不存在就返回错误

{

r=p->next;

p->next=r->next;

free（r）;

return0;

}

else

returnERROR;

}

statusdeletestu2（stu&s）//按姓名删除学生

{

chari[10];

cout<<"请输入你要删除学生的姓名"<

cin>>i;

student*p=s,*r;

while（strcmp（p->next->name,i）!

=0）//找到修改学生

{

p=p->next;

}

if（p）

{

r=p->next;

p->next=r->next;

free（r）;

return0;

}

else

returnERROR;

}

statusupdate1（stu&s）//按学号修改学生的信息

{

chari[10];

cout<<"请输入你要修改学生的学号"<

cin>>i;

student*p=s;

while（strcmp（p->num,i）!

=0）//找到修改学生

{

p=p->next;

}

if（p）

{

cin>>p;

return0;

}

else

returnERROR;

}

statusupdate2（stu&s）//按姓名修改学生的信息

{

chari[10];

cout<<"请输入你要修改学生的姓名"<

cin>>i;

student*p=s;

while（strcmp（p->name,i）!

=0）//找到修改学生

{

p=p->next;

}

if（p）

{

cin>>p;

return0;

}

else

returnERROR;

}

voidsort（stu&s,structshushuzu[]）//对总成绩排序

{

intn=0,i,j,k;

student*p=s->next;

while（p）{//获取多少个人数

n++;

p=p->next;

};

p=s->next;

for（i=1;i<=n;i++）//对结构体进行赋值

{shuzu[i].allscore=0;

for（j=0;j<4;j++）shuzu[i].allscore=shuzu[i].allscore+p->score[j];

strcpy（shuzu[i].num,p->num）;

p=p->next;

}

for（i=1;i

k=i;

for（j=i+1;j<=n;j++）

if（shuzu[j].allscore>shuzu[k].allscore）

k=j;

if（k!

=j）

{shuzu[0].allscore=shuzu[i].allscore;

strcpy（shuzu[0].num,shuzu[i].num）;

shuzu[i].allscore=shuzu[k].allscore;

strcpy（shuzu[i].num,shuzu[k].num）;

shuzu[k].allscore=shuzu[0].allscore;

strcpy（shuzu[k].num,shuzu[0].num）;

}

}

for（i=1;i<=n;i++）

{//对总成绩从大到小输出

p=s->next;

while（strcmp（p->num,shuzu[i].num）!

=0）//按学号查找相对应的学生信息

{

p=p->next;

}

cout<

"<

}

}

ostream&operator<<（ostream&os,stu&s）//输出函数的重载

{

os<<"学号:

"<num<<"姓名:

"<name<<"性别:

"<sex<<"科目1"<score[0]<<"科目2"<score[1]<<"科目3"<score[2]<<"科目4"<score[3]<

returnos;

}

istream&operator>>（istream&is,stu&s）//输入函数的重载

{cout<<""<<"学号"<<"姓名"<<"性别"<<"科目1"<<"科目2"<<"科目3"<<"科目4"<

is>>s->num>>s->name>>s->sex>>s->score[0]>>s->score[1]>>s->score[2]>>s->score[3];

returnis;

}CPP文件

#include

#include

#include

#include

#include"Status.h"

voidmenu（）

{

cout<<"********学生管理系统*******"<

cout<<"***1：

添加学生***"<

cout<<"***2：

显示信息***"<

cout<<"***3：

按学号查找***"<

cout<<"***4：

按姓名查找***"<

cout<<"***5:

插入学生***"<

cout<<"***6:

删除学生***"<

cout<<"***7:

修改学生***"<

cout<<"***8:

学生总成绩排序***"<

cout<<"*其他：

返回主菜单"<

cout<<"请选择";

}

intmain（）

{stus;

structshushuzu[10];

inti,k[4],j;

charc[9],p[9];

charx[20],o[20];

charl[3];

menu（）;

while

（1）

{

staticintn;

scanf（"%d",&n）;

switch（n）

{

case1:

cout<<"输入多少个学生"<>n;inputstu（s,n）;break;

case2:

output（s）;break;

case3:

cout<<"请输入你要找的学生学号:

";cin>>c;getstu1（s,c）;break;

case4:

cout<<"请输入你要找的学生姓名:

";cin>>x;getstu2（s,x）;break;

case5:

cout<<"需要插入位置，学号，姓名，性别,科目１，科目２，科目３，科目４"<

cin>>i>>p>>o>>l;for（j=0;j<4;j++）cin>>k[j];insetstu（s,i,p,o,l,k）;break;

case6:

cout<<"1:

按学号删除学生的信息;2:

按姓名删除学生的信息"<>j;

switch（j）{

case1:

deletestu1（s）;break;

case2:

deletestu2（s）;break;

};break;

case7:

cout<<"1:

按学号修改学生的信息;2:

按姓名修改学生的信息"<>j;

switch（j）{

case1:

update1（s）;break;

case2:

update2（s）;break;

};break;

case8:

sort（s,shuzu）;break;

default:

return0;

}

}

调试结果

5课程小结

我采用的是链表来存储学生的信息，最大的难点就是总成绩的排序，其他的功能实现还是比较简单，总成绩排序我用啦一个辅助结构体structshu来存储每个学生的学号charnum来记录学生以及便于排序的时候查找，还有总成绩floatallscore，且用结构体数组来存储首先对每个学生的学号及总成绩赋值给结构体数组shuzu[]，然后对结构体数组进行从大到小排序（选择排序）然后对结构体一一查找相应的信息。

假如用顺序表来存储可以避免这方面的麻烦。

最后对一个管理系统具有较好的结构，即对链表的一系列的操作熟悉及运用

同时也对数据结构这方面的认识深刻，数据存储的重要性。

数据结构在程序设计的重要性。

2：

joseph环

1任务分析

编号是1，2，……,n的n个人按照顺时针方向围坐一圈，每个人只有一个密码（正整数）。

一开始任选一个正整数作为报数上限值m,从第一个仍开始顺时针方向自1开始顺序报数，报到m时停止报数。

报m的人出列，将他的密码作为新的m值，从他在顺时针方向的下一个人开始重新从1报数，如此下去，直到所有人全部出列为止。

设计一个程序来求出出列顺序。

要求：

利用单向循环链表存储结构模拟此过程，按照出列的顺序输出各个人的编号。

测试数据：

m的初值为20，n=7,7个人的密码依次为3，1，7，2，4，7，4，首先m=6,则正确的输出是什么？

要求：

输入数据：

建立输入处理输入数据，输入m的初值，n，输入每个人的密码，建立单循环链表。

输出形式：

建立一个输出函数，将正确的输出序列

2结构分析

采用链表来存储每个人的密码每一次出列将密码为下一次报道的M。

并输出这个人。

直到所有人输出

3算法实现

头文件status.h

typedefintstatus;

#defineTURE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineOVERFLOW-2

typedefstructnode{//结构体存储密码

intmima;

structnode*next;

}nodelist,*nodeli;

voidcreatlist（nodeli&s,intn）//创建循环链表

{

nodelist*p,*r,*q;

inti;

s=（nodeli）malloc（sizeof（nodelist））;//申请空间

r=s;

cout<<"输入他们的密码:

"<

for（i=0;i

{

p=（nodelist*）malloc（sizeof（nodelist））;//创建人

if（i==0）

{

q=p;

cin>>p->mima;//输入密码

r->next=p;

r=p;

}

else

{

cin>>p->mima;//输入密码

r->next=p;//开始下一个

r=p;

}

}

r->next=q;

}

voidjoseph（nodeli&s,intm,intn）//joseph函数

{

nodelist*p=s,*q;

inti;

while（n!

=0）

{

i=1;

while（i

{

i++;p=p->next;

}

if（i=m）//找到目标

{

q=p->next;

p->next=q->next;

cout<mima<<"";//输出密码

m=q->mima;//把密码在复制给M找下一个

p=p->next;

free（q）;

n--;

}

}

cout<<"\n";

}

Cpp文件

#include

#include

#include

#include"status.h"

voidmain（）

{

nodelis;//定义个链表

intn,m=20,l;

cout<<"输入人的个数"<

cin>>n;//输入人的个数

creatlist（s,n）;//创建链表

cout<<"输入初始的M"<

cin>>l;

m=l;

joseph（s,m,n）;//JOSEPH函数调用

}

调试结果

4课程小结

这是一个典型的约瑟夫环差不多的问题只要熟练链表的操作就可以比较容易实现。

关键在于每一个的输出。

找下一个以上一次输出链表的密码来实现的。

关键对数据结构分析的重要。

链表的运用熟练

3：

猴子选大王

1任务分析

7、猴子选大王

一堆猴子都有编号，编号是1，2，3...m,这群猴子（m个）按照1-m的顺序围坐一圈，从第1开始数，每数到第N个，该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王。

要求：

输入数据：

输入m,nm,n为整数，n

输出形式：

中文提示按照m个猴子，数n个数的方法，输出为大王的猴子是几号，建立一个函数来实现此功能

2结构分析

采用链表来存储每个猴子的序号每一次出列将序号为下一次报道的M。

并输出这个猴子。

直到所有人输出最后的猴子为大王下次

3算法实现

Cpp文件

#include

#include

typedefstructhouzinode{

intnum;//猴子编号

structhouzinode*next;

}houzinode,*houzilist;//猴子类型

voidhouzidawan（houzilist&s,intn,intm）//求解猴子选大王问题最后输出的为大王

{

inti,j;

houzinode*r,*p,*q;

s=（houzilist）malloc（sizeof（houzinode））;//头结点

r=q=s;//rp指向头结点

q=r;

for（i=1;i<=n;i++）{

p=（houzilist）malloc（sizeof（houzinode））;//产生结点

p->num=i;//给猴子赋值

r->next=p;r=p;

}

r->next=q->next;//指向第一个猴子

p=q->next;

for（i=1;i

for（j=1;j

r=p;

p=p->next;

}

printf（"%d",p->num）;//输出即将淘汰的猴子

r->next=p->next;

free（p）;//淘汰去

p=r->next;

}

printf（"大王为%d\n",r->num）;//最后一个猴子

free（r）;

}

intmain（）

{

intn,m;

houzilists;

printf（"******猴子选大王******\n"）;

printf（"输入N,M:

"）;

scanf（"%d%d",&n,&m）;

printf（"出列人员的顺序为:

\n"）;

houzidawan（s,n,m）;//调用函数

return0;

}

调试结果

}4课程小结

这是一个典型的约瑟夫环的问题应用到生活中与上一个的题目一样只要熟练链表的操作就可以比较容易实现。

关键在于每一个猴子的输出。

找下一个以上一次输出链表的序号来实现的。

最后输出的猴子就是大王

东华理工大学

课程设计评分表

学生姓名：

洪军班级：

1421807学号：

201420180706

课程设计题目：

学生成绩管理系统

项目内容

满分

实评

选

题

能结合所学课程知识、有一定的能力训练。

符合选题要求

（5人一题）

10

工作量适中，难易度合理

10

能

力

水

平

能熟练应用所学知识，