学生成绩管理系统--单链表
程序员文章站
2022-10-05 09:06:22
注:还没写全局指针的回收处理。 头文件定义 STUHEADERFILES.h 因为是随兴而写的。函数注释是随着函数实现一起写的。等有时间再改过来。很多都不大合理，需要一起修改。 STUSCORES.h LISTMODE_MODE_INSERT.c文件 LISTMODE_MODE_MODIFY.c文件 ......
注:还没写全局指针的回收处理。
头文件定义
stuheaderfiles.h
#ifndef _stuheaderfiles_h_ #define _stuheaderfiles_h_ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "stuscores.h" #endif
因为是随兴而写的。函数注释是随着函数实现一起写的。等有时间再改过来。很多都不大合理，需要一起修改。
stuscores.h
#ifndef _stuscores_h_
#define _stuscores_h_
/*宏定义*/
#define max_id 30 //id最大字节数
#define max_name 30 //姓名最大字节数
#define max_sex 4 //性别最大字节数
/*结构体别名定义*/
typedef struct sistudentinfor *ptrstudentinformation; //函数类型指针定义
typedef struct sistudentinfor varstudentinformaiton; //自变量定义
/*嵌套结构体定义*/
struct sistudentscoreinfor
{
double dscorestotol;
double dscoreseve;
};
/*学生成绩管理系统结构体定义*/
struct sistudentinfor
{
char cid[max_id]; //id编号
char csname[max_name]; //姓名
char cssex[max_sex]; //性别
int isage; //年龄
int isgrade; //年级
int isclass; //班级
int isseat; //座位
float fschinese; //语文成绩
float fsmath; //数学成绩
float fsenglish; //英语成绩
struct sistudentscoreinfor *sistudentscore; //成绩统计结构
ptrstudentinformation ptrnext; //指针域
};
/*全局指针定义*/
varstudentinformaiton *ptrstunodes; //头节点
varstudentinformaiton *ptrsortnodes; //排序头节点
varstudentinformaiton *ptrnewnodes; //新节点
/*文件名:listmode_mode_insert.c*/
void mode_data_push(varstudentinformaiton **ptrpushnodes, varstudentinformaiton **ptrnewnodes);
void mode_data_push_option(varstudentinformaiton **ptrpushnodes, varstudentinformaiton **ptrnewnodes);
/*文件名:listmode_mode_modify.c*/
void mode_node_modify_id(varstudentinformaiton **currentnodes);
void mode_node_modify_name(varstudentinformaiton **currentnodes);
void mode_node_modify_sex(varstudentinformaiton **currentnodes);
void mode_node_modify_age(varstudentinformaiton **currentnodes);
void mode_node_modify_grade(varstudentinformaiton **currentnodes);
void mode_node_modify_class(varstudentinformaiton **currentnodes);
void mode_node_modify_seat(varstudentinformaiton **currentnodes);
void mode_node_modify_china(varstudentinformaiton **currentnodes);
void mode_node_modify_math(varstudentinformaiton **currentnodes);
void modifymodeenglish(varstudentinformaiton **currentnodes);
void mode_node_modify_option(varstudentinformaiton **ptrlishnodes);
/*文件名:listmode_mode_query.c*/
void mode_querry_id(varstudentinformaiton *ptrquerrynodes);
void mode_querry_name(varstudentinformaiton *ptrquerrynodes);
void mode_querry_sex(varstudentinformaiton *ptrquerrynodes);
void mode_querry_age(varstudentinformaiton *ptrquerrynodes);
void mode_querry_grade(varstudentinformaiton *ptrquerrynodes);
void mode_querry_class(varstudentinformaiton *ptrquerrynodes);
void mode_querry_seat(varstudentinformaiton *ptrquerrynodes);
void mode_querry_china(varstudentinformaiton *ptrquerrynodes);
void mode_querry_math(varstudentinformaiton *ptrquerrynodes);
void mode_querry_english(varstudentinformaiton *ptrquerrynodes);
void mode_querry_total(varstudentinformaiton *ptrquerrynodes);
void mode_querry_average(varstudentinformaiton *ptrquerrynodes);
void mode_querry_choose(varstudentinformaiton *ptrquerrynodes);
/*文件名:listmode_mode_remove.c*/
void mode_data_remove(varstudentinformaiton **ptrlistnode);
/*文件名:listmode_mode_show.c*/
void mode_show_choose(varstudentinformaiton *ptrlistmode);
/*文件名:listmode_mode_sort.c*/
ptrstudentinformation mode_sort_china(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes);
ptrstudentinformation mode_sort_math(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes);
ptrstudentinformation mode_sort_english(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes);
ptrstudentinformation mode_sort_total(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes);
ptrstudentinformation mode_sort_average(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes);
ptrstudentinformation mode_sort_ascending_china(varstudentinformaiton *listhead);
ptrstudentinformation mode_sort_ascending_math(varstudentinformaiton *listhead);
ptrstudentinformation mode_sort_ascending_english(varstudentinformaiton *listhead);
ptrstudentinformation mode_sort_ascending_total(varstudentinformaiton *listhead);
ptrstudentinformation mode_sort_ascending_average(varstudentinformaiton *listhead);
void mode_sort_choose(varstudentinformaiton *listnode);
/*文件名:listmode_modifyoption.c*/
void modifymodes_id(varstudentinformaiton **currentlistnode, char tomodifynodesid[max_id]);
void modifymodes_name(varstudentinformaiton **currentlistnode, char tomodifynodesname[max_name]);
void modifymodes_sex(varstudentinformaiton **currentlistnode, char tomodifynodessex[max_sex]);
void modifymodes_age(varstudentinformaiton **currentlistnode, int tomodifynodesage);
void modifymodes_grade(varstudentinformaiton **currentlistnode, int tomodifynodesgrade);
void modifymodes_class(varstudentinformaiton **currentlistnode, int tomodifynodesclass);
void modifymodes_seat(varstudentinformaiton **currentlistnode, int tomodifynodesseat);
void modifymodes_china(varstudentinformaiton **currentlistnode, float tomodifynodeschina);
void modifymodes_math(varstudentinformaiton **currentlistnode, float tomodifynodesmath);
void modifymodes_english(varstudentinformaiton **currentlistnode, float tomodifynodesenglish);
/*文件名:student_listnode_booljudge.c*/
int bool_headnode_null(varstudentinformaiton *ptrheadnodes);
/*文件名:student_listnode_filesoption.c*/
void listnode_files_write(varstudentinformaiton *ptrlistheadnode);
void listnode_files_create_newnodes(file **readfiles, varstudentinformaiton **ptrlistnewnodes);
void listnode_files_read(varstudentinformaiton *ptrlistheadnode);
/*文件名:student_listnode_init.c*/
ptrstudentinformation listnode_init_headnodes(varstudentinformaiton *var_head);
/*文件名:student_listnode_insert.c*/
ptrstudentinformation listnode_insert_create_newnodes(varstudentinformaiton *ptrlist_newnodes, char cid[max_id], char cname[max_name], char csex[max_sex], int iage, int igrade, int iclass, int iseat, float fchinese, float fmath, float fenglish);
ptrstudentinformation listnode_insert_push_firstnodes(varstudentinformaiton *ptrheadnodes, varstudentinformaiton *ptrnewnodes);
ptrstudentinformation listnode_insert_push_lastnodes(varstudentinformaiton *ptrlist_nodes, varstudentinformaiton *ptrlistnew);
void listnode_insert_push_specifiednodes(varstudentinformaiton **ptrcurrentlist_nodes, varstudentinformaiton *ptrnewnodes);
void listnode_insert_push_specifiednodes_head(varstudentinformaiton **ptrcurrentlist_nodes, varstudentinformaiton *ptrnewnodes);
/*文件名:student_listnode_interface.c*/
void listnode_interface_sort(varstudentinformaiton *varlishnode);
void listnode_interface_querry(varstudentinformaiton *varlishnode);
void listnode_interface_modify(varstudentinformaiton **ptrlishnode);
void listnode_interface_show();
void listnode_interface_student_mode();
void listnode_interface_student(void);
/*文件名:student_listnode_remove.c*/
void listnode_remove_node(varstudentinformaiton **ptrnode);
void listnode_remove_headnodes(varstudentinformaiton **ptrfirstnode);
void listnode_remove_lastnodes(varstudentinformaiton **ptrnodes);
void listnode_remove_specifiednodes(varstudentinformaiton **ptrnodes);
void listnode_remove_allnodes(varstudentinformaiton **ptrnodes);
/*文件名:student_listnode_traverseshow.c*/
ptrstudentinformation listnode_traverse_current_id(varstudentinformaiton *ptrlist_nodes, char serchid[max_id]);
void listnode_traverse_current_id_show(varstudentinformaiton *ptrlist_nodes, char serchid[max_id]);
void listnode_traverse_current_name_show(varstudentinformaiton *ptrlist_nodes, char serchname[max_name]);
void listnode_traverse_current_sex_show(varstudentinformaiton *ptrlist_nodes, char serchsex[max_sex]);
void listnode_traverse_current_age_show(varstudentinformaiton *ptrlist_nodes, int ivarage);
void listnode_traverse_current_grade_show(varstudentinformaiton *ptrlist_nodes, int ivargrade);
void listnode_traverse_current_class_show(varstudentinformaiton *ptrlist_nodes, int ivarclass);
void listnode_traverse_current_seat_show(varstudentinformaiton *ptrlist_nodes, int ivarseat);
void listnode_traverse_current_china_show(varstudentinformaiton *ptrlist_nodes, float fvarchina);
void listnode_traverse_current_math_show(varstudentinformaiton *ptrlist_nodes, float fvarmath);
void listnode_traverse_current_eng_show(varstudentinformaiton *ptrlist_nodes, float fvareng);
void listnode_traverse_current_aver_show(varstudentinformaiton *ptrlist_nodes, double dvareve);
void listnode_traverse_current_total_show(varstudentinformaiton *ptrlist_nodes, double dvartotol);
void listnode_traverse_order_show(varstudentinformaiton *varlist_nodes);
void listnode_traverse_current_reverse_show(varstudentinformaiton *varlist_nodes);
void listnode_traverse_current_node_show(varstudentinformaiton *varlisttemp);
void listnode_traverse_asc_messagebox();
void listnode_traverse_order_messagebox();
#endif
listmode_mode_insert.c文件
#include "stuheaderfiles.h"
/*
函数:
mode_data_push
功能:
录入数据
并插入链表尾部(尾插法添加节点)
参数:
ptrpushnodes:
结构体二级指针
接收链表头节点
ptrnewnodes:
结构体二级指针
传入一个已录入数据的新节点
返回值:
无返回值
*/
void mode_data_push(varstudentinformaiton **ptrpushnodes, varstudentinformaiton **ptrnewnodes)
{
char m_id[max_id];
char m_name[max_name];
char m_sex[max_sex];
int m_age, m_grade, m_class, m_seat;
float m_china, m_math, m_english;
printf("id:");
scanf_s("%s",m_id,max_id);
printf("姓名:");
scanf_s("%s", m_name, max_name);
printf("性别:");
scanf_s("%s", m_sex, max_sex);
printf("年龄:");
scanf_s("%d", &m_age);
printf("年级:");
scanf_s("%d", &m_grade);
printf("班级:");
scanf_s("%d", &m_class);
printf("座位:");
scanf_s("%d", &m_seat);
printf("语文成绩:");
scanf_s("%f", &m_china);
printf("数这成绩:");
scanf_s("%f", &m_math);
printf("英语成绩:");
scanf_s("%f", &m_english);
(*ptrnewnodes) = listnode_insert_create_newnodes((*ptrnewnodes), m_id, m_name, m_sex, m_age, m_grade, m_class, m_seat, m_china, m_math, m_english);
(*ptrpushnodes) = listnode_insert_push_lastnodes((*ptrpushnodes), (*ptrnewnodes));
}
/*
函数:
mode_data_push_option
功能:
录入数据条件功能模块。输入y录入节点数据，输入n退出操作
参数:
ptrpushnodes
结构体二级指针
接收链表头节点
ptrnewnodes:
结构体二级指针
接收一个已分配内存并录入数据的新节点
返回值:
无返回值
*/
void mode_data_push_option(varstudentinformaiton **ptrpushnodes,varstudentinformaiton **ptrnewnodes)
{
char isyes;
printf("输入y:继续操作，输入n退出操作:\n");
scanf_s("%*[\n]%c",&isyes,4);
while (isyes=='y'||isyes=='y')
{
mode_data_push(ptrpushnodes,ptrnewnodes);
printf("输入y:继续操作，输入n退出操作:\n");
scanf_s("%*[\n]%c", &isyes,4);
}
}
listmode_mode_modify.c文件
#include "stuheaderfiles.h"
/*
函数:mode_node_modify_id
功能:修改当前节点的id数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_id(varstudentinformaiton **currentnodes)
{
char setid[max_id];
printf("需要修改的id：");
scanf_s("%s",setid,max_id);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_id(currentnodes, setid);
printf("id修改成功!\n");
}
/*
函数:mode_node_modify_name
功能:修改当前节点的id数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_name(varstudentinformaiton **currentnodes)
{
char setname[max_name];
printf("需要修改的姓名：");
scanf_s("%s", setname, max_name);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_name(currentnodes, setname);
printf("姓名修改成功!\n");
}
/*
函数:mode_node_modify_sex
功能:修改当前节点的sex数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_sex(varstudentinformaiton **currentnodes)
{
char setsex[max_sex];
printf("需要修改的性别：");
scanf_s("%s", setsex, max_sex);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_sex(currentnodes, setsex);
printf("性别修改成功!\n");
}
/*
函数:mode_node_modify_age
功能:修改当前节点的age数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_age(varstudentinformaiton **currentnodes)
{
int setage;
printf("需要修改的年龄：");
scanf_s("%d", &setage);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_age(currentnodes, setage);
printf("年龄修改成功!\n");
}
/*
函数:mode_node_modify_grade
功能:修改当前节点的grade数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_grade(varstudentinformaiton **currentnodes)
{
int setgrade;
printf("需要修改的年级：");
scanf_s("%d", &setgrade);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_grade(currentnodes, setgrade);
printf("年级修改成功!\n");
}
/*
函数:mode_node_modify_class
功能:修改当前节点的class数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_class(varstudentinformaiton **currentnodes)
{
int setclass;
printf("需要修改的班级：");
scanf_s("%d", &setclass);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_class(currentnodes, setclass);
printf("班级修改成功!\n");
}
/*
函数:mode_node_modify_seat
功能:修改当前节点的seat数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_seat(varstudentinformaiton **currentnodes)
{
int setseat;
printf("需要修改的座位：");
scanf_s("%d", &setseat);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_seat(currentnodes, setseat);
printf("座位修改成功!\n");
}
/*
函数:mode_node_modify_china
功能:修改当前节点的chinese数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_china(varstudentinformaiton **currentnodes)
{
float setchina;
printf("需要修改的语文成绩：");
scanf_s("%f", &setchina);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_china(currentnodes, setchina);
printf("语文成绩修改成功!\n");
}
/*
函数:mode_node_modify_math
功能:修改当前节点的math数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void mode_node_modify_math(varstudentinformaiton **currentnodes)
{
float setmath;
printf("需要修改的数学成绩：");
scanf_s("%f", &setmath);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_math(currentnodes, setmath);
printf("数学成绩修改成功!\n");
}
/*
函数:mode_node_modify_english
功能:修改当前节点的math数据
参数:
currentnodes:结构体指针，接收当前节点，非空节点
返回值:无返回值
*/
void modifymodeenglish(varstudentinformaiton **currentnodes)
{
float setenglis;
printf("需要修改的英语成绩：");
scanf_s("%f", &setenglis);
(*currentnodes) = (*currentnodes)->ptrnext;
modifymodes_english(currentnodes, setenglis);
printf("英语成绩修改成功!\n");
}
/*
函数:mode_node_modify_option
功能:学生成绩修改模块
参数:
ptrlishnodes:
结构体二级指针
接收头节点
返回值:
无返回值
*/
void mode_node_modify_option(varstudentinformaiton **ptrlishnodes)
{
int imodifyflag;
varstudentinformaiton *varmodifynode;
char serchid[max_id];
varmodifynode = (*ptrlishnodes);
printf("输入需要修改的数据的id:");
scanf_s("%s", serchid, max_id);
varmodifynode=listnode_traverse_current_id(varmodifynode, serchid);
printf("选择需要执行的操作项:");
scanf_s("%d",&imodifyflag);
switch (imodifyflag)
{
case 1:
mode_node_modify_id(&varmodifynode);
break;
case 2:
mode_node_modify_name(&varmodifynode);
break;
case 3:
mode_node_modify_sex(&varmodifynode);
break;
case 4:
mode_node_modify_age(&varmodifynode);
break;
case 5:
mode_node_modify_grade(&varmodifynode);
break;
case 6:
mode_node_modify_class(&varmodifynode);
break;
case 7:
mode_node_modify_seat(&varmodifynode);
break;
case 8:
mode_node_modify_china(&varmodifynode);
break;
case 9:
mode_node_modify_math(&varmodifynode);
break;
case 10:
modifymodeenglish(&varmodifynode);
break;
case 0:
listnode_interface_student();//主菜单界面
break;
default:
printf("错误的操作!\n");
break;
}
printf("按回车键返回主界面");
getchar();
getchar();
system("cls");
}
listmode_mode_query.c文件
#include "stuheaderfiles.h"
/*
函数:mode_querry_id
功能:匹配查询的id
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_id(varstudentinformaiton *ptrquerrynodes)
{
char cqueid[max_id];
printf("输入需要查询的id:");
scanf_s("%s",cqueid,max_id);
listnode_traverse_current_id_show(ptrquerrynodes, cqueid);
}
/*
函数:mode_querry_name
功能:匹配查询的name
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_name(varstudentinformaiton *ptrquerrynodes)
{
char cquename[max_name];
printf("输入需要查询的姓名:");
scanf_s("%s", cquename, max_name);
listnode_traverse_current_name_show(ptrquerrynodes, cquename);
}
/*
函数:mode_querry_sex
功能:匹配查询的sex
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_sex(varstudentinformaiton *ptrquerrynodes)
{
char cquesex[max_sex];
printf("输入需要查询的性别:");
scanf_s("%s", cquesex, max_sex);
listnode_traverse_current_sex_show(ptrquerrynodes, cquesex);
}
/*
函数:mode_querry_sex
功能:匹配查询的age
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_age(varstudentinformaiton *ptrquerrynodes)
{
int iqueage;
printf("输入需要查询的性别:");
scanf_s("%d", &iqueage);
listnode_traverse_current_age_show(ptrquerrynodes, iqueage);
}
/*
函数:mode_querry_grade
功能:匹配查询的grade
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_grade(varstudentinformaiton *ptrquerrynodes)
{
int iqueage;
printf("输入需要查询的年级:");
scanf_s("%d", &iqueage);
listnode_traverse_current_grade_show(ptrquerrynodes, iqueage);
}
/*
函数:mode_querry_class
功能:匹配查询的grade
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_class(varstudentinformaiton *ptrquerrynodes)
{
int iqueclass;
printf("输入需要查询的年级:");
scanf_s("%d", &iqueclass);
listnode_traverse_current_class_show(ptrquerrynodes, iqueclass);
}
/*
函数:mode_querry_seat
功能:匹配查询的seat
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_seat(varstudentinformaiton *ptrquerrynodes)
{
int iqueseat;
printf("输入需要查询的座位:");
scanf_s("%d", &iqueseat);
listnode_traverse_current_seat_show(ptrquerrynodes, iqueseat);
}
/*
函数:mode_querry_china
功能:匹配查询的china
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_china(varstudentinformaiton *ptrquerrynodes)
{
float fquechina;
printf("输入需要查询的座位:");
scanf_s("%f", &fquechina);
listnode_traverse_current_china_show(ptrquerrynodes, fquechina);
}
/*
函数:mode_querry_math
功能:匹配查询的math
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_math(varstudentinformaiton *ptrquerrynodes)
{
float fquemath;
printf("输入需要查询的座位:");
scanf_s("%f", &fquemath);
listnode_traverse_current_math_show(ptrquerrynodes, fquemath);
}
/*
函数:mode_querry_english
功能:匹配查询的math
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_english(varstudentinformaiton *ptrquerrynodes)
{
float fqueeng;
printf("输入需要查询的座位:");
scanf_s("%f", &fqueeng);
listnode_traverse_current_eng_show(ptrquerrynodes, fqueeng);
}
/*
函数:mode_querry_total
功能:匹配查询的totol
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_total(varstudentinformaiton *ptrquerrynodes)
{
double dquetotol;
printf("输入需要查询的座位:");
scanf_s("%f", &dquetotol);
listnode_traverse_current_total_show(ptrquerrynodes, dquetotol);
}
/*
函数:mode_querry_average
功能:匹配查询的eve
参数:
ptrquerrynodes：结构体指针参数，接收一个头节点
返回值:无返回值
*/
void mode_querry_average(varstudentinformaiton *ptrquerrynodes)
{
double dqueeve;
printf("输入需要查询的座位:");
scanf_s("%f", &dqueeve);
listnode_traverse_current_aver_show(ptrquerrynodes, dqueeve);
}
/*
函数:mode_querry_choose
功能:学生成绩查询模块
参数:
ptrquerrynodes：
结构体指针参数
接收一个头节点
返回值:
无返回值
*/
void mode_querry_choose(varstudentinformaiton *ptrquerrynodes)
{
int iqueflags=0;
scanf_s("%d",&iqueflags);
switch (iqueflags)
{
case 1:
mode_querry_id(ptrquerrynodes);
break;
case 2:
mode_querry_name(ptrquerrynodes);
break;
case 3:
mode_querry_sex(ptrquerrynodes);
break;
case 4:
mode_querry_age(ptrquerrynodes);
break;
case 5:
mode_querry_grade(ptrquerrynodes);
break;
case 6:
mode_querry_class(ptrquerrynodes);
break;
case 7:
mode_querry_class(ptrquerrynodes);
break;
case 8:
mode_querry_china(ptrquerrynodes);
break;
case 9:
mode_querry_math(ptrquerrynodes);
break;
case 10:
mode_querry_english(ptrquerrynodes);
break;
case 11:
mode_querry_total(ptrquerrynodes);
break;
case 12:
mode_querry_average(ptrquerrynodes);
break;
case 0:
listnode_interface_student();
break;
default:
{
printf("错误的操作!\n");
listnode_interface_student();
}
break;
}
}
listmode_mode_remove.c文件
#include "stuheaderfiles.h"
/*
函数:
mode_data_remove
功能:指定删除的id后匹配id并删除指定的节点
参数:
ptrlistnode
结构体二级指针
接收头节点
返回值:
无返回值
*/
void mode_data_remove(varstudentinformaiton **ptrlistnode)
{
char getdeldata[max_id];
varstudentinformaiton *ptrlistnodetemp;
ptrlistnodetemp = (*ptrlistnode);
scanf_s("%s",getdeldata,max_id);
if ((*ptrlistnode) == null)
{
printf("空链表!\n");
return;
}
if ((*ptrlistnode)->ptrnext == null)
{
printf("空链表!\n");
return;
}
listnode_traverse_current_id_show(ptrlistnodetemp, getdeldata);
if (ptrlistnodetemp->ptrnext != null)
{
listnode_remove_specifiednodes(ptrlistnodetemp);
}
if (ptrlistnodetemp->ptrnext == null)
{
listnode_remove_lastnodes(ptrlistnodetemp);
}
}
listmode_mode_show.c文件
#include "stuheaderfiles.h"
/*
函数:
mode_show_choose
功能:遍历并显示学生成绩链表数据模块
参数:
ptrlistmode
结构体指针
接收头节点
返回值:
无返回值
*/
void mode_show_choose(varstudentinformaiton *ptrlistmode)
{
int ishowflag;
printf("================学生成绩管理系统============================\n\n");
printf("\t\t1.顺序显示\n\n\t\t2.逆序显示.\n\n\t\t3.返回主菜单\n\n");
printf("================学生成绩管理系统============================\n\n");
printf("请输入选择项:");
scanf_s("%d",&ishowflag);
system("cls");
switch (ishowflag)
{
case 1:
printf("\n顺序显示学生成绩数据如下表:\n\n");
listnode_traverse_order_show(ptrlistmode);
break;
case 2:
printf("\n逆序显示学生成绩数据如下表:\n\n");
listnode_traverse_current_reverse_show(ptrlistmode);
break;
case 3:
listnode_interface_student();
break;
default:
printf("错误的操作!\n");
break;
}
printf("按回车键返回主菜单!");
getchar();
getchar();
system("cls");
}
listmode_mode_sort.c文件
#include "stuheaderfiles.h"
/*
函数:
mode_sort_china
功能:
语文成绩的比较
两个相邻节点进行比较
如果左节点比相邻右节点大
节点进行交换
参数:
listleftheadnodes
左半部节点
listrightheadnodes
右半部节点
返回值:
recvnewnodes->ptrnext
*/
ptrstudentinformation mode_sort_china(varstudentinformaiton *listleftheadnodes,varstudentinformaiton *listrightheadnodes)
{
varstudentinformaiton *recvnewnodes;
varstudentinformaiton *p1, *p2;
recvnewnodes = (ptrstudentinformation)malloc(sizeof(varstudentinformaiton));
recvnewnodes->ptrnext = listleftheadnodes;
p2 = listrightheadnodes;
p1 = recvnewnodes;
while (p1->ptrnext!=null&&p2!=null)
{
if (p1->ptrnext->fschinese > p2->fschinese)
{
listrightheadnodes = p2->ptrnext;
p2->ptrnext = p1->ptrnext;
p1->ptrnext = p2;
p1 = p2;
p2 = listrightheadnodes;
}
else
{
p1 = p1->ptrnext;
}
}
if (p1->ptrnext == null) //l2可能还有未处理的结点，直接加在l1尾部即可
{
p1->ptrnext = p2;
}
return recvnewnodes->ptrnext;
}
/*
函数:
mode_sort_math
功能:
数学成绩的比较
两个相邻节点进行比较
如果左节点比相邻右节点大
节点进行交换
参数:
listleftheadnodes
左半部节点
listrightheadnodes
右半部节点
返回值:
recvnewnodes->ptrnext
*/
ptrstudentinformation mode_sort_math(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes)
{
varstudentinformaiton *recvnewnodes;
varstudentinformaiton *p1, *p2;
recvnewnodes = (ptrstudentinformation)malloc(sizeof(varstudentinformaiton));
recvnewnodes->ptrnext = listleftheadnodes;
p2 = listrightheadnodes;
p1 = recvnewnodes;
while (p1->ptrnext != null&&p2 != null)
{
if (p1->ptrnext->fsmath > p2->fsmath)
{
listrightheadnodes = p2->ptrnext;
p2->ptrnext = p1->ptrnext;
p1->ptrnext = p2;
p1 = p2;
p2 = listrightheadnodes;
}
else
{
p1 = p1->ptrnext;
}
}
if (p1->ptrnext == null) //l2可能还有未处理的结点，直接加在l1尾部即可
{
p1->ptrnext = p2;
}
return recvnewnodes->ptrnext;
}
/*
函数:
mode_sort_english
功能:
英语成绩的比较
两个相邻节点进行比较
如果左节点比相邻右节点大
节点进行交换
参数:
listleftheadnodes
左半部节点
listrightheadnodes
右半部节点
返回值:
recvnewnodes->ptrnext
*/
ptrstudentinformation mode_sort_english(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes)
{
varstudentinformaiton *recvnewnodes;
varstudentinformaiton *p1, *p2;
recvnewnodes = (ptrstudentinformation)malloc(sizeof(varstudentinformaiton));
recvnewnodes->ptrnext = listleftheadnodes;
p2 = listrightheadnodes;
p1 = recvnewnodes;
while (p1->ptrnext != null&&p2 != null)
{
if (p1->ptrnext->fsenglish > p2->fsenglish)
{
listrightheadnodes = p2->ptrnext;
p2->ptrnext = p1->ptrnext;
p1->ptrnext = p2;
p1 = p2;
p2 = listrightheadnodes;
}
else
{
p1 = p1->ptrnext;
}
}
if (p1->ptrnext == null) //l2可能还有未处理的结点，直接加在l1尾部即可
{
p1->ptrnext = p2;
}
return recvnewnodes->ptrnext;
}
/*
函数:
mode_sort_total
功能:
总成绩的比较
两个相邻节点进行比较
如果左节点比相邻右节点大
节点进行交换
参数:
listleftheadnodes
左半部节点
listrightheadnodes
右半部节点
返回值:
recvnewnodes->ptrnext
*/
ptrstudentinformation mode_sort_total(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes)
{
varstudentinformaiton *recvnewnodes;
varstudentinformaiton *p1, *p2;
recvnewnodes = (ptrstudentinformation)malloc(sizeof(varstudentinformaiton));
recvnewnodes->ptrnext = listleftheadnodes;
p2 = listrightheadnodes;
p1 = recvnewnodes;
while (p1->ptrnext != null&&p2 != null)
{
if (p1->ptrnext->sistudentscore->dscorestotol > p2->sistudentscore->dscorestotol)
{
listrightheadnodes = p2->ptrnext;
p2->ptrnext = p1->ptrnext;
p1->ptrnext = p2;
p1 = p2;
p2 = listrightheadnodes;
}
else
{
p1 = p1->ptrnext;
}
}
if (p1->ptrnext == null) //l2可能还有未处理的结点，直接加在l1尾部即可
{
p1->ptrnext = p2;
}
return recvnewnodes->ptrnext;
}
/*
函数:
mode_sort_average
功能:
平均成绩的比较
两个相邻节点进行比较
如果左节点比相邻右节点大
节点进行交换
参数:
listleftheadnodes
左半部节点
listrightheadnodes
右半部节点
返回值:
recvnewnodes->ptrnext
*/
ptrstudentinformation mode_sort_average(varstudentinformaiton *listleftheadnodes, varstudentinformaiton *listrightheadnodes)
{
varstudentinformaiton *recvnewnodes;
varstudentinformaiton *p1, *p2;
recvnewnodes = (ptrstudentinformation)malloc(sizeof(varstudentinformaiton));
recvnewnodes->ptrnext = listleftheadnodes;
p2 = listrightheadnodes;
p1 = recvnewnodes;
while (p1->ptrnext != null&&p2 != null)
{
if (p1->ptrnext->sistudentscore->dscoreseve > p2->sistudentscore->dscoreseve)
{
listrightheadnodes = p2->ptrnext;
p2->ptrnext = p1->ptrnext;
p1->ptrnext = p2;
p1 = p2;
p2 = listrightheadnodes;
}
else
{
p1 = p1->ptrnext;
}
}
if (p1->ptrnext == null) //l2可能还有未处理的结点，直接加在l1尾部即可
{
p1->ptrnext = p2;
}
return recvnewnodes->ptrnext;
}
//============================================
/*
函数:
mode_sort_ascending_china
功能:
进行语文成绩的升序排序
参数:
listhead
结构体指针
接收一个头节点
返回值:
mode_sort_china(lefthead,righthead);
*/
ptrstudentinformation mode_sort_ascending_china(varstudentinformaiton *listhead)
{
varstudentinformaiton *slow, *fast;
varstudentinformaiton *lefthead, *righthead;
slow = listhead;
fast = listhead;
lefthead = listhead;
if (listhead == null || listhead->ptrnext == null)
{
return listhead;
}
while (slow->ptrnext!=null)
{
if (fast->ptrnext->ptrnext != null)
{
fast = fast->ptrnext->ptrnext;
slow = slow->ptrnext;
}
if (fast->ptrnext == null)
{
break;
}
if (fast->ptrnext->ptrnext == null)
{
break;
}
}
righthead = slow->ptrnext;
slow->ptrnext = null;
lefthead = mode_sort_ascending_china(lefthead);
righthead = mode_sort_ascending_china(righthead);
return mode_sort_china(lefthead,righthead);
}
/*
函数:
mode_sort_ascending_math
功能:
进行数学成绩的升序排序
参数:
listhead
结构体指针
接收一个头节点
返回值:
mode_sort_math(lefthead, righthead);
*/
ptrstudentinformation mode_sort_ascending_math(varstudentinformaiton *listhead)
{
varstudentinformaiton *slow, *fast;
varstudentinformaiton *lefthead, *righthead;
slow = listhead;
fast = listhead;
lefthead = listhead;
if (listhead == null || listhead->ptrnext == null)
{
return listhead;
}
while (slow->ptrnext != null)
{
if (fast->ptrnext->ptrnext != null)
{
fast = fast->ptrnext->ptrnext;
slow = slow->ptrnext;
}
if (fast->ptrnext == null)
{
break;
}
if (fast->ptrnext->ptrnext == null)
{
break;
}
}
righthead = slow->ptrnext;
slow->ptrnext = null;
lefthead = mode_sort_ascending_math(lefthead);
righthead = mode_sort_ascending_math(righthead);
return mode_sort_math(lefthead, righthead);
}
/*
函数:
mode_sort_ascending_english
功能:
进行英语成绩的升序排序
参数:
listhead
结构体指针
接收一个头节点
返回值:
mode_sort_english(lefthead, righthead);
*/
ptrstudentinformation mode_sort_ascending_english(varstudentinformaiton *listhead)
{
varstudentinformaiton *slow, *fast;
varstudentinformaiton *lefthead, *righthead;
slow = listhead;
fast = listhead;
lefthead = listhead;
if (listhead == null || listhead->ptrnext == null)
{
return listhead;
}
while (slow->ptrnext != null)
{
if (fast->ptrnext->ptrnext != null)
{
fast = fast->ptrnext->ptrnext;
slow = slow->ptrnext;
}
if (fast->ptrnext == null)
{
break;
}
if (fast->ptrnext->ptrnext == null)
{
break;
}
}
righthead = slow->ptrnext;
slow->ptrnext = null;
lefthead = mode_sort_ascending_english(lefthead);
righthead = mode_sort_ascending_english(righthead);
return mode_sort_english(lefthead, righthead);
}
/*
函数:
mode_sort_ascending_total
功能:
进行总成绩的升序排序
参数:
listhead
结构体指针
接收一个头节点
返回值:
mode_sort_english(lefthead, righthead);
*/
ptrstudentinformation mode_sort_ascending_total(varstudentinformaiton *listhead)
{
varstudentinformaiton *slow, *fast;
varstudentinformaiton *lefthead, *righthead;
slow = listhead;
fast = listhead;
lefthead = listhead;
if (listhead == null || listhead->ptrnext == null)
{
return listhead;
}
while (slow->ptrnext != null)
{
if (fast->ptrnext->ptrnext != null)
{
fast = fast->ptrnext->ptrnext;
slow = slow->ptrnext;
}
if (fast->ptrnext == null)
{
break;
}
if (fast->ptrnext->ptrnext == null)
{
break;
}
}
righthead = slow->ptrnext;
slow->ptrnext = null;
lefthead = mode_sort_ascending_total(lefthead);
righthead = mode_sort_ascending_total(righthead);
return mode_sort_total(lefthead, righthead);
}
/*
函数:
mode_sort_ascending_average
功能:
进行平均成绩的升序排序
参数:
listhead
结构体指针
接收一个头节点
返回值:
mode_sort_average(lefthead, righthead);
*/
ptrstudentinformation mode_sort_ascending_average(varstudentinformaiton *listhead)
{
varstudentinformaiton *slow, *fast;
varstudentinformaiton *lefthead, *righthead;
slow = listhead;
fast = listhead;
lefthead = listhead;
if (listhead == null || listhead->ptrnext == null)
{
return listhead;
}
while (slow->ptrnext != null)
{
if (fast->ptrnext->ptrnext != null)
{
fast = fast->ptrnext->ptrnext;
slow = slow->ptrnext;
}
if (fast->ptrnext == null)
{
break;
}
if (fast->ptrnext->ptrnext == null)
{
break;
}
}
righthead = slow->ptrnext;
slow->ptrnext = null;
lefthead = mode_sort_ascending_average(lefthead);
righthead = mode_sort_ascending_average(righthead);
return mode_sort_average(lefthead, righthead);
}
/*=================================================================================*/
/*下面是降序排序*/
//=================================================
/*
函数:
mode_sort_choose
功能:
升序、降序排序选择操作项功能模块
参数:
listnode
结构体指针
接收一个头节点
返回值:
无返回值
*/
void mode_sort_choose(varstudentinformaiton *listnode)
{
int isort_flag;
printf("请输入操作的选择项:");
scanf("%d",&isort_flag);
system("cls");
switch (isort_flag)
{
case 1:
{
listnode = mode_sort_ascending_china(listnode);
listnode_traverse_asc_messagebox();
listnode_traverse_order_show(listnode);
}
break;
case 2:
{
listnode = mode_sort_ascending_math(listnode);
listnode_traverse_asc_messagebox();
listnode_traverse_order_show(listnode);
}
break;
case 3:
{
listnode = mode_sort_ascending_english(listnode);
listnode_traverse_asc_messagebox();
listnode_traverse_order_show(listnode);
}
break;
case 4:
{
listnode = mode_sort_ascending_total(listnode);
listnode_traverse_asc_messagebox();
listnode_traverse_order_show(listnode);
}
break;
case 5:
{
listnode = mode_sort_ascending_average(listnode);
listnode_traverse_asc_messagebox();
listnode_traverse_order_show(listnode);
}
break;
case 6:
{
listnode = mode_sort_ascending_china(listnode);
listnode_traverse_order_messagebox();
listnode_traverse_current_reverse_show(listnode);
}
break;
case 7:
{
listnode = mode_sort_ascending_math(listnode);
listnode_traverse_order_messagebox();
listnode_traverse_current_reverse_show(listnode);
}
break;
case 8:
{
listnode = mode_sort_ascending_english(listnode);
listnode_traverse_order_messagebox();
listnode_traverse_current_reverse_show(listnode);
}
break;
case 9:
{
listnode = mode_sort_ascending_total(listnode);
listnode_traverse_order_messagebox();
listnode_traverse_current_reverse_show(listnode);
}
break;
case 10:
{
listnode = mode_sort_ascending_average(listnode);
listnode_traverse_order_messagebox();
listnode_traverse_current_reverse_show(listnode);
}
break;
case 0:
listnode_interface_student();
break;
default:
{
printf("错误的操作!\n");
listnode_interface_student();
}
break;
}
printf("按回车键返回选择项菜单!");
getchar();
getchar();
system("cls");
listnode_interface_sort(listnode);
}
listmode_modifyoption.c文件
#include "stuheaderfiles.h"
/*
函数:modifymodes_id
功能:修改当前节点的id数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesid:char类型，大小为max_id.
返回值:无返回值
*/
void modifymodes_id(varstudentinformaiton **currentlistnode,char tomodifynodesid[max_id] )
{
strcpy((*currentlistnode)->cid,tomodifynodesid);
}
/*
函数:modifymodes_name
功能:修改当前节点的id数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesname:char类型，大小为max_id.
返回值:无返回值
*/
void modifymodes_name(varstudentinformaiton **currentlistnode, char tomodifynodesname[max_name])
{
strcpy((*currentlistnode)->csname, tomodifynodesname);
}
/*
函数:modifymodes_sex
功能:修改当前节点的sex数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodessex:char类型，大小为max_sex.
返回值:无返回值
*/
void modifymodes_sex(varstudentinformaiton **currentlistnode, char tomodifynodessex[max_sex])
{
strcpy((*currentlistnode)->cssex, tomodifynodessex);
}
/*
函数:modifymodes_age
功能:修改当前节点的age数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesage:int类型
返回值:无返回值
*/
void modifymodes_age(varstudentinformaiton **currentlistnode, int tomodifynodesage)
{
(*currentlistnode)->isage = tomodifynodesage;
}
/*
函数:modifymodes_grade
功能:修改当前节点的grade数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesgrade:int类型
返回值:无返回值
*/
void modifymodes_grade(varstudentinformaiton **currentlistnode, int tomodifynodesgrade)
{
(*currentlistnode)->isgrade = tomodifynodesgrade;
}
/*
函数:modifymodes_class
功能:修改当前节点的class数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesclass:int类型
返回值:无返回值
*/
void modifymodes_class(varstudentinformaiton **currentlistnode, int tomodifynodesclass)
{
(*currentlistnode)->isclass = tomodifynodesclass;
}
/*
函数:modifymodes_seat
功能:修改当前节点的seat数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesseat:int类型
返回值:无返回值
*/
void modifymodes_seat(varstudentinformaiton **currentlistnode, int tomodifynodesseat)
{
(*currentlistnode)->isseat = tomodifynodesseat;
}
/*
函数:modifymodes_china
功能:修改当前节点的chinese数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodeschina:float类型,接收一个匹配的语文 成绩
返回值:无返回值
*/
void modifymodes_china(varstudentinformaiton **currentlistnode, float tomodifynodeschina)
{
(*currentlistnode)->fschinese = tomodifynodeschina;
}
/*
函数:modifymodes_math
功能:修改当前节点的math数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesmath:float类型,接收一个匹配的数学 成绩
返回值:无返回值
*/
void modifymodes_math(varstudentinformaiton **currentlistnode, float tomodifynodesmath)
{
(*currentlistnode)->fsmath = tomodifynodesmath;
}
/*
函数:modifymodes_english
功能:修改当前节点的english数据
参数:
currentlistnode:结构体二级指针，接收当前节点，非空节点
tomodifynodesenglish:float类型,接收一个匹配的英语 成绩
返回值:无返回值
*/
void modifymodes_english(varstudentinformaiton **currentlistnode, float tomodifynodesenglish)
{
(*currentlistnode)->fsenglish = tomodifynodesenglish;
}
student_listnode_booljudge.c文件
#include "stuheaderfiles.h"
/*
函数: bool_headnode_null
功能:判断传入的节点是否为null，为null返回1，否则返回0
参数:
ptrheadnodes:结构体指针变量,接收一个结构体指针参数。链表头节点指针
返回值:返回1或者0
*/
int bool_headnode_null(varstudentinformaiton *ptrheadnodes)
{
if (ptrheadnodes == null)
{
return 1;
}
return 0;
}
student_listnode_filesoption.c文件
#include "stuheaderfiles.h"
/*
函数: listnode_files_write
功能:链表节点数据写入文件
参数:
ptrlistheadnode:结构体二级指针变量,接收一个结构体指针参数。链表头节点指针
返回值:无返回值
*/
void listnode_files_write(varstudentinformaiton *ptrlistheadnode)
{
file *savenodetofile;
varstudentinformaiton *ptrlistnodetemp = ptrlistheadnode->ptrnext;
fopen_s(&savenodetofile, "studentfiles.txt", "wt");
if (savenodetofile == null)
{
printf("创建或打开文件失败\n");
return;
}
while (ptrlistnodetemp != null)
{
fprintf_s(savenodetofile, "%s\t", ptrlistnodetemp->cid, max_id);
fprintf_s(savenodetofile, "%s\t", ptrlistnodetemp->csname, max_name);
fprintf_s(savenodetofile, "%s\t", ptrlistnodetemp->cssex, max_sex);
fprintf_s(savenodetofile, "%d\t", ptrlistnodetemp->isage);
fprintf_s(savenodetofile, "%d\t", ptrlistnodetemp->isgrade);
fprintf_s(savenodetofile, "%d\t", ptrlistnodetemp->isclass);
fprintf_s(savenodetofile, "%d\t", ptrlistnodetemp->isseat);
fprintf_s(savenodetofile, "%f\t", ptrlistnodetemp->fschinese);
fprintf_s(savenodetofile, "%f\t", ptrlistnodetemp->fsmath);
fprintf_s(savenodetofile, "%f\t", ptrlistnodetemp->fsenglish);
fprintf_s(savenodetofile, "%.3lf\t", ptrlistnodetemp->sistudentscore->dscorestotol);
fprintf_s(savenodetofile, "%.3lf\r\n", ptrlistnodetemp->sistudentscore->dscoreseve);
/*if (fwrite(ptrlistnodetemp, sizeof(varstudentinformaiton) + sizeof(struct sistudentscoreinfor), 12, savenodetofile) != 12)
{
printf("数据写入文件失败!\n");
return;
}*/
ptrlistnodetemp = ptrlistnodetemp->ptrnext;
}
printf("数据写入文件成功!\n");
fclose(savenodetofile);
}
void listnode_files_create_newnodes(file **readfiles,varstudentinformaiton **ptrlistnewnodes)
{
(*ptrlistnewnodes) =(ptrstudentinformation) malloc(sizeof(varstudentinformaiton));
(*ptrlistnewnodes)->sistudentscore = (struct sistudentinfor *)malloc(sizeof(struct sistudentinfor));
if ((*ptrlistnewnodes) == null)
{
printf("reade data newnodes malloc field!\n");
return;
}
(*ptrlistnewnodes)->ptrnext = null;
fscanf((*readfiles), "%s", (*ptrlistnewnodes)->cid);
fscanf((*readfiles), "%s", (*ptrlistnewnodes)->csname);
fscanf((*readfiles), "%s", (*ptrlistnewnodes)->cssex);
fscanf((*readfiles), "%d", &(*ptrlistnewnodes)->isage);
fscanf((*readfiles), "%d", &(*ptrlistnewnodes)->isgrade);
fscanf((*readfiles), "%d", &(*ptrlistnewnodes)->isclass);
fscanf((*readfiles), "%d", &(*ptrlistnewnodes)->isseat);
fscanf((*readfiles), "%f", &(*ptrlistnewnodes)->fschinese);
fscanf((*readfiles), "%f", &(*ptrlistnewnodes)->fsmath);
fscanf((*readfiles), "%f", &(*ptrlistnewnodes)->fsenglish);
fscanf((*readfiles), "%lf", &(*ptrlistnewnodes)->sistudentscore->dscorestotol);
fscanf((*readfiles), "%lf\n", &(*ptrlistnewnodes)->sistudentscore->dscoreseve);
}
void listnode_files_read(varstudentinformaiton *ptrlistheadnode)
{
file *savenodetofile=null;
varstudentinformaiton *ptrnewnodes = null;
savenodetofile=fopen("studentfiles.txt", "r");
if (savenodetofile == null)
{
printf("创建或打开文件失败\n");
return;
}
fseek(savenodetofile, 0l, seek_set);
while (!feof(savenodetofile))
{
listnode_files_create_newnodes(&savenodetofile,&ptrnewnodes);
ptrlistheadnode=listnode_insert_push_lastnodes(ptrlistheadnode, ptrnewnodes);
}
printf("读取文件成功!\n");
fclose(savenodetofile);
}
student_listnode_init.c文件
#include "stuheaderfiles.h"
/*
函数: listnode_init_headnodes
功能:创建一个节点，并分配内存。
参数:
var_head:结构体二级指针变量,接收一个指针参数
返回值:无返回值
*/
ptrstudentinformation listnode_init_headnodes(varstudentinformaiton *var_head)
{
var_head = (ptrstudentinformation)malloc(sizeof(varstudentinformaiton));
var_head->sistudentscore = (struct sistudentscoreinfor*)malloc(sizeof(struct sistudentscoreinfor));
if (var_head == null)
{
return null;
}
if (var_head->sistudentscore == null)
{
return null;
}
var_head->ptrnext = null;
return var_head;
}
student_listnode_insert.c文件
#include "stuheaderfiles.h"
/*
函数: listnode_insert_create_newnodes
功能:创建新的节点并且录入数据
参数:
ptrlist_newnodes:结构体指针变量,接收一个结构体指针参数
cid:数据类型char,参数id对应结构体id成员
cname:数据类型char,参数cname对应结构体csname成员
csex:数据类型char,参数csex对应结构体cssex成员
iage:数据类型int,参数iage对应结构体isage成员
igrade:数据类型int,参数igrade对应结构体isgrade成员
iclass:数据类型int,参数iclass对应结构体isclass成员
fchinese:数据类型float,参数fchinese对应结构体fschinese成员
fmath:数据类型float,参数fmath对应结构体fsmath成员
fenglish:数据类型float,参数fenglish对应结构体fsenglish成员
返回值:ptrlistnew
*/
ptrstudentinformation listnode_insert_create_newnodes(varstudentinformaiton *ptrlist_newnodes, char cid[max_id], char cname[max_name], char csex[max_sex], int iage, int igrade, int iclass, int iseat, float fchinese, float fmath, float fenglish)
{
//varstudentinformaiton *ptrlistnew;
ptrlist_newnodes = (ptrstudentinformation)malloc(sizeof(varstudentinformaiton));
ptrlist_newnodes->sistudentscore = (struct sistudentscoreinfor*)malloc(sizeof(struct sistudentscoreinfor));
if (ptrlist_newnodes == null)
{
return null;
}
if (ptrlist_newnodes->sistudentscore == null)
{
return null;
}
strcpy(ptrlist_newnodes->cid, cid);
strcpy(ptrlist_newnodes->csname, cname);
strcpy(ptrlist_newnodes->cssex, csex);
ptrlist_newnodes->isage = iage;
ptrlist_newnodes->isgrade = igrade;
ptrlist_newnodes->isclass = iclass;
ptrlist_newnodes->isseat = iseat;
ptrlist_newnodes->fschinese = fchinese;
ptrlist_newnodes->fsmath = fmath;
ptrlist_newnodes->fsenglish = fenglish;
ptrlist_newnodes->sistudentscore->dscorestotol = fchinese + fmath + fenglish;
ptrlist_newnodes->sistudentscore->dscoreseve = (ptrlist_newnodes->sistudentscore->dscorestotol) / 3;
ptrlist_newnodes->ptrnext = null;
return ptrlist_newnodes;
}
/*
函数: listnode_insert_push_firstnodes
功能:头插法添加结构体成员各节点
参数:
ptrheadnodes:结构体指针变量,接收一个结构体指针参数。链表头节点指针
ptrnewnodes:结构体指针变量，接收一个结构体指针参数。已创建的并且已录入数据的新节点
返回值:ptrheadnodes
*/
ptrstudentinformation listnode_insert_push_firstnodes(varstudentinformaiton *ptrheadnodes, varstudentinformaiton *ptrnewnodes)
{
varstudentinformaiton *ptrheadnodestemp;//临时指针，指向当前节点位置
ptrheadnodestemp = ptrheadnodes->ptrnext;//因为这个原先的head->next节点,需要被移到后面去。所以要先保存一下
if (ptrheadnodes == null)
{
//printf("空链表\n");
return null;
}
ptrheadnodes->ptrnext = ptrnewnodes;//head的下一个节点指向新创建的new节点
ptrheadnodes->ptrnext->ptrnext = ptrheadnodestemp;//上面的新节点指向之后，就是处理原来旧节点了。把它移到后面去。
ptrheadnodes = ptrnewnodes;//链接新节点
return ptrheadnodes;
}
/*
函数: listnode_insert_push_lastnodes
功能:尾插法添加结构体成员各数据
参数:
ptrlist_nodes:结构体指针变量,接收一个结构体指针参数。链表头节点指针
ptrlistnew:结构体指针变量，接收一个结构体指针参数。已创建的并且已录入数据的新节点
返回值:ptrlist_nodes
*/
ptrstudentinformation listnode_insert_push_lastnodes(varstudentinformaiton *ptrlist_nodes, varstudentinformaiton *ptrlistnew)
{
varstudentinformaiton *ptrlisttemp;
varstudentinformaiton *ptrheadtemp;
ptrlisttemp = ptrlist_nodes;
ptrheadtemp = ptrlist_nodes;
if (ptrheadtemp->ptrnext == null)
{
ptrheadtemp->ptrnext = ptrlistnew;
ptrheadtemp = ptrheadtemp->ptrnext;
ptrheadtemp = ptrlistnew;
}
else
{
while (ptrlisttemp->ptrnext != null)
{
ptrlisttemp = ptrlisttemp->ptrnext;
}
ptrlisttemp->ptrnext = ptrlistnew;
ptrlisttemp = ptrlisttemp->ptrnext;
ptrlisttemp = ptrlistnew;
}
return ptrlist_nodes;
}
/*
函数: listnode_insert_push_specifiednodes
功能:在指定节点后面插入数据
参数:
ptrlist_nodes:结构体指针变量,接收一个结构体指针参数。链表头节点指针
ptrnewnodes:结构体指针变量，接收一个结构体指针参数。已创建的并且已录入数据的新节点
ptrcurrentlist_nodes:结构体指针变量，接收一个结构体指针参数。当前节点位置指针
返回值:ptrlist_nodes
其它:非head节点和last节点的插入
*/
void listnode_insert_push_specifiednodes(varstudentinformaiton **ptrcurrentlist_nodes, varstudentinformaiton *ptrnewnodes)
{
(*ptrcurrentlist_nodes) = (*ptrcurrentlist_nodes)->ptrnext;//添加这一行，因为遍历到的是前一个节点.
varstudentinformaiton *ptrnodeslist = (*ptrcurrentlist_nodes)->ptrnext;
(*ptrcurrentlist_nodes)->ptrnext = ptrnewnodes;
(*ptrcurrentlist_nodes) = (*ptrcurrentlist_nodes)->ptrnext;
(*ptrcurrentlist_nodes)->ptrnext = ptrnodeslist;
(*ptrcurrentlist_nodes) = ptrnewnodes;
}
/*
函数: listnode_insert_push_specifiednodes_head
功能:在指定节点前面插入数据
参数:
ptrlist_nodes:结构体指针变量,接收一个结构体指针参数。链表头节点指针
ptrnewnodes:结构体指针变量，接收一个结构体指针参数。已创建的并且已录入数据的新节点
ptrcurrentlist_nodes:结构体指针变量，接收一个结构体指针参数。当前节点位置指针
返回值:ptrlist_nodes
其它:非head节点和last节点的插入
*/
void listnode_insert_push_specifiednodes_head(varstudentinformaiton **ptrcurrentlist_nodes, varstudentinformaiton *ptrnewnodes)
{
varstudentinformaiton *ptrnodeslist = (*ptrcurrentlist_nodes)->ptrnext;
(*ptrcurrentlist_nodes)->ptrnext = ptrnewnodes;
(*ptrcurrentlist_nodes) = (*ptrcurrentlist_nodes)->ptrnext;
(*ptrcurrentlist_nodes)->ptrnext = ptrnodeslist;
(*ptrcurrentlist_nodes) = ptrnewnodes;
}
student_listnode_interface.c文件
#include "stuheaderfiles.h"
/*
函数:
listnode_interface_sort
功能:
查询功能界面：
语英数成绩、平均、总成绩升序、降序排序功能模块的界面显示
参数:
varlishnode
接收头节点
返回值:
无返回值
*/
void listnode_interface_sort(varstudentinformaiton *varlishnode)
{
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("0.返 回 上一层 界面.\n");
mode_sort_choose(varlishnode);
}
/*
函数:
listnode_interface_querry
功能:
查询功能界面：
id、姓名、性别、年龄、年级、班级、座位、语英数成绩、平均、总成绩查询的界面显示
参数:
varlishnode
接收头节点
返回值:
无返回值
*/
void listnode_interface_querry(varstudentinformaiton *varlishnode)
{
printf("1.id查询.\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("11.总成绩查询.\n");
printf("12.平均成绩查询.\n");
printf("0.返回上一层界面\n");
mode_querry_choose(varlishnode);
}
/*
函数:
listnode_interface_modify
功能:
数据修改功能界面：
id、姓名、性别、年龄、年级、班级、座位、语英数成绩、平均、总成绩修改的界面显示
参数:
ptrlishnode
结构体二级指针
接收头节点
返回值:
无返回值
*/
void listnode_interface_modify(varstudentinformaiton **ptrlishnode)
{
printf("================学生成绩管理系统============================\n\n");
printf("\t\t操作选项:\n\n");
printf("\t\t1.id修改.\n\n");
printf("\t\t2.姓名修改.\n\n");
printf("\t\t3.性别修改.\n\n");
printf("\t\t4.年龄修改.\n\n");
printf("\t\t5.年级修改.\n\n");
printf("\t\t6.班级修改.\n\n");
printf("\t\t7.座位修改.\n\n");
printf("\t\t8.语文成绩修改.\n\n");
printf("\t\t9.数学成绩修改.\n\n");
printf("\t\t10.英语成绩修改.\n\n");
printf("\t\t0.返回上一层界面\n\n");
printf("================学生成绩管理系统============================\n\n");
mode_node_modify_option(ptrlishnode);
}
/*
函数:
listnode_interface_show
功能:
学生成绩管理系统数据显示选择功能界面：
1.顺序显示
2.逆序显示
参数:
无
返回值:
无返回值
*/
void listnode_interface_show()
{
printf("选择操作:\n");
printf("1.顺序显示学生成绩列表!\n");
printf("2.逆序显示学生成绩列表!\n");
printf("3.返回上一层操作!\n");
}
/*
函数:
listnode_interface_student_mode
功能:
学生成绩管理系统主界面功能模块
参数:
无
返回值:
无返回值
*/
void listnode_interface_student_mode()
{
int chooseflags;
printf("请输入选择操作:\n");
scanf_s("%d", &chooseflags);
system("cls");
switch (chooseflags)
{
case 1:
{
mode_data_push_option(&ptrstunodes, &ptrnewnodes); //学生成绩录入模块
break;
}
case 2:
listnode_interface_querry(ptrstunodes); //学生成绩查询模块
break;
case 3:
listnode_interface_modify(&ptrstunodes); //学生成绩数据修改模块
break;
case 4:
mode_data_remove(&ptrstunodes); //学生成绩数据删除模块
break;
case 5:
{
ptrsortnodes = ptrstunodes;
listnode_interface_sort(ptrsortnodes); //学生成绩排序模块
}
break;
case 6:
mode_show_choose(ptrstunodes); //学生成绩显示模块
break;
case 7:
listnode_files_write(ptrstunodes); //学生成绩数据保存文件模块
break;
case 8:
listnode_files_read(ptrstunodes); //学生成绩数据读入模块
break;
case 0:
return;
break;
default:
printf("错误的操作!\n");
break;
}
listnode_interface_student();
}
/*
函数:
listnode_interface_student
功能：
显示学生成绩管理系统主界面
参数:
无
返回值:
无
*/
void listnode_interface_student(void)
{
printf("================学生成绩管理系统============================\n");
printf("\t\t1.学生成绩录入\n");
printf("\t\t2.学生成绩查询\n");
printf("\t\t3.学生成绩修改\n");
printf("\t\t4.学生成绩删除\n");
printf("\t\t5.学生成绩排序\n");
printf("\t\t6.学生成绩显示\n");
printf("\t\t7.学生成绩保存\n");
printf("\t\t8.学生成绩载入\n");
printf("\t\t0.退出操作\n");
printf("================学生成绩管理系统============================\n");
listnode_interface_student_mode();
}
student_listnode_remove.c文件
#include "stuheaderfiles.h"
/*
函数: listnode_remove_node
功能:释放当前指针和嵌套结构体内存
参数:
ptrnode:结构体二级指针变量,接收一个结构体指针参数。链表当前节点指针
返回值:无返回值
*/
void listnode_remove_node(varstudentinformaiton **ptrnode)
{
free((*ptrnode)->sistudentscore);
free((*ptrnode));
}
/*
函数: listnode_remove_headnodes
功能:删除首节点和数据
参数:
ptrfirstnode:结构体二级指针变量,接收一个结构体指针参数。链表头节点指针
返回值:无返回值
*/
void listnode_remove_headnodes(varstudentinformaiton **ptrfirstnode)
{
varstudentinformaiton *todeleteheadnode;
varstudentinformaiton *tonewnode = (*ptrfirstnode)->ptrnext;
todeleteheadnode = tonewnode; //获取删除的节点
tonewnode->ptrnext = todeleteheadnode->ptrnext; //删除后面的节点给链接临时节点，这一句执行后，并不是tohead就是直接得到后面节点
tonewnode = tonewnode->ptrnext; //这里直接得到后面的节点。
listnode_remove_node(&todeleteheadnode); //这时就可以释放删除的节点了。
((*ptrfirstnode)->ptrnext) = tonewnode; //头节点重新链接后面的节点
todeleteheadnode = null; //置空临时节点
}
/*
函数: ptrnodes
功能:删除链表尾部节点和数据
参数:
ptrnodes:结构体二级指针变量,接收一个结构体指针参数。链表当前节点指针
返回值:无返回值
*/
void listnode_remove_lastnodes(varstudentinformaiton **ptrnodes)
{
varstudentinformaiton *todelete; //待删除的节点
todelete = (*p
赞 (0)
打赏
微信扫一扫
相关文章:
-
-
这是一个参数解析，可以用它快捷的为你的程序生成参数相关功能 import argparse(导入程序参数模块) # 创建argparse对象，并将产... [阅读全文]
-
如何配置Open Live Writer程序以便更好的为博客服务
Open Live Writer的前身是Windows live Writer 即（WLW）是一个免费的桌面应用程序，您可以使用它轻松发布丰富的内容... [阅读全文] -
从零开始的Python学习Episode 19——面向对象（2）
面向对象之继承 继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称 为基类或超类，新建的类称为派生类或子... [阅读全文] -
版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。
发表评论