基于双向循环链表实现的学生管理系统

最新推荐文章于 2022-12-20 14:49:46 发布
最新推荐文章于 2022-12-20 14:49:46 发布
阅读量485 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43357542/article/details/100784719
版权

运行主菜单如图所示

student.c文件所示
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
#include"student.h"
INT32 main(VOID)
{
CHAR chstuName[MAXNAMELENGTH];
NODE psthead = create_list();/创建双向循环链表/
init_list(psthead);
menu();
while (1)
{
INT32 u32len = len_list(psthead);
printf(“请输入您要进行的操作:(如需查看菜单指令请输入5):\n”);
UINT32 u32select = 0;
while(0==scanf("%d",&u32select))/scanf输入数字时返回1，否则返回0/
{
fflush(stdin);/清理缓存/
printf(“输入错误,请输入数字:”);
}
switch (u32select)
{
case 1:/插入/
insert_student(psthead);
system(“CLS”);
id_sort(psthead, u32len+1);
printf(" 学生信息管理系统\n");
printf("**************************************************************\n\n");
print_list(psthead);
printf("***************************************************************\n\n");
break;
case 2:/删除/
delete_student(psthead);
id_sort(psthead, u32len-1);
printf(" 学生信息管理系统\n");
printf("***************************************************************\n\n");
print_list(psthead);
printf("***************************************************************\n\n");
break;
case 3:/查找/
search(psthead);
break;
case 4: /修改/
{
updata_student(psthead);
id_sort(psthead, u32len);
printf(" 学生信息管理系统\n");
printf("***************************************************************\n\n");
print_list(psthead);
printf("***************************************************************\n\n");
}
break;
case 5:
system(“CLS”);
menu();
break;
case 6:/排序/
system(“CLS”);
sort(psthead, u32len);
printf("\n");
printf(" 学生信息管理系统\n");
printf("***************************************************************\n\n");
print_list(psthead);
printf("***************************************************************\n\n");
break;
case 7:
system(“CLS”);
printf(“感谢您的使用，学生管理系统已经退出！\n\n”);
exit(0);
break;
default:
printf(“输入错误!\n\n”);
}
}
return 0;
}
/创建双向循环链表/
NODE * create_list()
{
NODE *psthead = (NODE )malloc(sizeof(NODE));
if (psthead!=NULL)
{
psthead->left = psthead;
psthead->right = psthead;
return psthead;
}
else
return NULL;
}
/初始化链表，创建15条任意的默认考生记录/
VOID init_list(NODE psthead)
{
Student newStudent;
for(UINT32 i=0;i<15;i++)/生成15个名字/
{
INT32 u32k=0;
INT32 u32flag=rand()%2;/判偶判奇/
newStudent.number=RANDNUMBER+i;/生成学号/
for(UINT32 j=0;j<6;j++)/每个名字由6个字母组成/
{
if(u32flag)
{
newStudent.name[u32k++]=‘A’+rand()%26;/每次生成26个字母中的一个大写字母(u32flag=1)/
}
else
{
newStudent.name[u32k++]=‘a’+rand()%26;/每次生成26个字母中的一个小写字母(u32flag=0)/
}
}
newStudent.name[u32k]=’\0’;/姓名字符串结束标志符/
newStudent.age=2i+20;/生成20以上的年龄/
newStudent.score=2i+30;/生成30以上的成绩/
insert_list(psthead, newStudent);/将每次生成的1个学生信息加入链表/
}
print_list(psthead);
}
/菜单中插入功能调度函数/
INT32 insert_student(NODE *psthead)
{
NODE *p=(NODE *)malloc(sizeof(NODE));
Student newStudent;
printf(“请输入学生信息：\n\n”);
updata_Id(psthead ,p);/插入学号/
updata_name§;/插入姓名/
updata_age§;/插入年龄/
updata_score§;/插入成绩/
newStudent.number=p->student.number;
strcpy(newStudent.name,p->student.name);
newStudent.age=p->student.age;
newStudent.score=p->student.score;
insert_list(psthead, newStudent);
free§;
p=NULL;
return 1;
}
/结点插入/
/插入功能实现函数，头插法插入/
INT32 insert_list(NODE *psthead, Student data)
{
NODE *newNODE = (NODE *)malloc(sizeof(NODE));
if (newNODE!=NULL)
{
newNODE->student = data;

    newNODE->left = psthead;
    newNODE->right = psthead->right;

    psthead->right = newNODE;
    newNODE->right->left = newNODE;

    return 1;
}
else
    return -1;
}
/菜单中删除功能的调度函数/
INT32 delete_student(NODE psthead)
{
while(1)
{
UINT32 u32input;
printf(“请输入您要进行的操作：1-删除指定姓名 2-删除所有学生(释放链表) 3-删除指定学号 4-返回上一层:\n\n”);
while(0scanf("%d",&u32input))/scanf输入数字时返回1，否则返回0/
{
fflush(stdin);/清理缓存/
printf(“输入错误,请输入数字:”);
}
switch(u32input)
{
case 1:
{
printf("\n请输入需要删除的学生的姓名：");
CHAR name[NAMELENGTH];
scanf("%s",name);
delete_node(psthead, name);
}
break;
case 2:
delete_all_node(psthead);
printf(“所有学生删除完毕，链表已经释放!\n\n”);
break;
case 3:
{
printf("\n请输入需要删除的学生的学号：");
UINT32 u32DeleteId;
while(0scanf("%d",&u32DeleteId))/scanf输入数字时返回1，否则返回0/
{
fflush(stdin);/清理缓存/
printf(“输入错误,请输入数字:”);
}
/ scanf("%d",&u32DeleteId);/
delete_id(psthead, u32DeleteId);
break;
}
case 4:
return 0;
default:
break;
}
}
return 0;
}
/删除指定姓名的实现函数/
INT32 delete_node(NODE psthead, CHAR name)
{
NODE searchStudent = name_node(psthead, name);
if(NULLsearchStudent)
{
printf("\n没有您要删除的姓名!\n\n");
}
while(searchStudent!=NULL)
{
searchStudent->left->right = searchStudent->right;
searchStudent->right->left = searchStudent->left;
free(searchStudent);
printf("\n该学生已删除!\n\n");
searchStudent = name_node(psthead, name);
}
return 0;
}
/删除某个学号的实现函数/
INT32 delete_id(NODE *psthead, UINT32 u32Id)
{
NODE *searchStudent=id_node(psthead, u32Id);
if(NULLsearchStudent)
{
printf(“没有您要删除的学号!\n\n”);
}
while(searchStudent!=NULL)
{
searchStudent->left->right = searchStudent->right;
searchStudent->right->left = searchStudent->left;
free(searchStudent);
printf("\n该学生已删除!\n\n");
searchStudent = id_node(psthead, u32Id);
}
return 0;
}
/删除全部学生实现函数/
VOID delete_all_node(NODE psthead)
{
NODE p = psthead->right;
NODE p_next = NULL;
while(p!=psthead)
{
psthead->right = p->right;
p->right->left = psthead;
free§;
p= psthead->right;
}
}
/查找总函数/
VOID search(NODE psthead)
{
while(1)
{
UINT32 u32input;
printf(“请输入查找的内容： 1-年龄 2-成绩 3-姓名(前后) 4-关键字 5-链首尾 6-姓名(重名) 7-学号 8-返回上一层\n”);
scanf("%d",&u32input);
switch(u32input)
{
case 1:
search_age(psthead);/查找年龄范围/
break;
case 2:
search_score(psthead);/查找成绩范围/
break;
case 3:
search_name(psthead);/查找姓名/
break;
case 4:
search_keywords(psthead);/查找关键字/
break;
case 5:
search_rh(psthead);/查找链首尾/
break;
case 6:
char searchName[40];/名字最大长度为40字节/
printf(“请输入您要查找的姓名:”);
scanf("%s",searchName);
printf(" 查找的学生信息如下:\n");
printf("*******************************************************\n\n");
all_name_node(psthead,searchName);/查找全部姓名/
printf("***************************************************************\n\n");
break;
case 7:
{
UINT32 u32searchNum;
printf(“请输入您要查找的学号:”);
scanf("%d",&u32searchNum);
printf(" 查找的学生信息如下:\n");
printf("***************************************************************\n\n");
NODE IdNode=id_node(psthead ,u32searchNum);
if(IdNode==NULL)
{
printf(" 查无此人\n");
}
else
{
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", IdNode->student.number, IdNode->student.name, IdNode->student.age,IdNode->student.score);
}
printf("**************************************************************\n\n");
break;
}
case 8:
return;
default:
printf(“输入错误!”);
search(psthead);
break;
}
}

}
/查找年龄函数/
VOID search_age(NODE psthead)
{
printf(“请输入需要查找的学生的年龄范围:\n\n”);
UINT32 u32ageMin;
UINT32 u32ageMax;
printf(“请输入最小年龄ageMin:”);
scanf("%d", &u32ageMin);
printf(“请输入最大年龄ageMax:”);
scanf("%d", &u32ageMax);
age_node(psthead, u32ageMin,u32ageMax);
printf(" 查找的学生信息如下:\n");
printf("**************************************************************\n\n");
printf(" 学号\t\t姓名\t\t年龄\t\t成绩\n\n");
if(u32countAge==0)
{
printf(" 查无此人\n");
printf("***************************************************************\n");
return;
}
else
{
for(UINT32 i=0;i<u32countAge;i++)
{
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", stuAge[i].number, stuAge[i].name, stuAge[i].age,stuAge[i].score);
}
printf("***************************************************************\n");
u32countAge=0;
}
}
/查找年龄实现函数/
VOID age_node(NODE *psthead, UINT32 u32ageMin,UINT32 u32ageMax)
{
NODE *left = psthead;
NODE *right = psthead;
do
{
left = left->left;
right = right->right;
if ((left->student.age>=u32ageMin)&&(left->student.age<=u32ageMax))
{
stuAge[u32countAge++]=left->student;
}
if ((left != right)&&(right->student.age>=u32ageMin)&&(right->student.age<=u32ageMax))
{
stuAge[u32countAge++]=right->student;
}
} while (left != right && left->left != right);

}
/查找成绩函数/
VOID search_score(NODE psthead)
{
printf(“请输入需要查找的学生的成绩范围:\n\n”);
UINT32 u32ScoreMin;
UINT32 u32ScoreMax;
printf(“请输入最小成绩ScoreMin:”);
scanf("%d", &u32ScoreMin);
printf(“请输入最大成绩ScoreMax:”);
scanf("%d", &u32ScoreMax);
score_node(psthead, u32ScoreMin, u32ScoreMax);
printf(" 查找的学生信息如下:\n");
printf("**************************************************************\n\n");
printf(" 学号\t\t姓名\t\t年龄\t\t成绩\n\n");
if(u32countScore==0)
{
printf(" 查无此人\n");
printf("***************************************************************\n");
return;
}
else
{
for(UINT32 i=0;i<u32countScore;i++)
{
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", stuAge[i].number, stuAge[i].name, stuAge[i].age,stuAge[i].score);
}
printf("***************************************************************\n\n");
u32countScore=0;
}
}
/查找成绩的实现函数/
NODE *score_node(NODE *psthead, UINT32 u32ScoreMin, UINT32 u32ScoreMax)
{
NODE *left = psthead;
NODE *right = psthead;
do
{
left = left->left;
right = right->right;
if ((left->student.score>=u32ScoreMin)&&(left->student.score<=u32ScoreMax))
{
stuAge[u32countScore++]=left->student;
}
if ((left != right)&&(right->student.score>=u32ScoreMin)&&(right->student.score<=u32ScoreMax))
{
stuAge[u32countScore++]=right->student;
}
} while (left != right && left->left != right);

return NULL;
1
}
/查找名字函数/
VOID search_name(NODE psthead)
{
printf(“请输入需要查找的学生的姓名:\n\n”);
CHAR name[NAMELENGTH];
scanf("%s", name);
getchar();
NODE result = name_node(psthead, name);
printf(" 查找的学生信息如下:\n");
printf("*************************************************************\n\n");
if (result!=NULL)
{
printf(" 学号\t\t姓名\t\t年龄\t\t成绩\n\n");
if(psthead!=result->left)
{
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", result->left->student.number, result->left->student.name,result->left->student.age, result->left->student.score);
}
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", result->student.number, result->student.name, result->student.age, result->student.score);
if(psthead!=(result->right))
{
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", result->right->student.number, result->right->student.name, result->right->student.age, result->right->student.score);
}
}
else
printf(" 查无此人\n");
printf("***************************************************************\n");
}

/查找名字的实现函数/
NODE *name_node(NODE *psthead, CHAR *studentName)
{
NODE *left = psthead;
NODE *right = psthead;
do
{
left = left->left;
right = right->right;
if (strcmp(left->student.name,studentName)==0)
return left;
if (strcmp(right->student.name,studentName)==0)
return right;
} while (left != right && left->left != right);

return NULL;
1
}
/查找全部名字函数/
VOID all_name_node(NODE *psthead, CHAR *studentName)
{
NODE *left = psthead;
NODE *right = psthead;
printf(" 学号\t\t姓名\t\t年龄\t\t成绩\n\n");
do
{
left = left->left;
right = right->right;
if (strcmp(left->student.name,studentName)0)
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", left->student.number, left->student.name,left->student.age, left->student.score);
if (strcmp(right->student.name,studentName)0)
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", right->student.number, right->student.name,right->student.age, right->student.score);
} while (left != right && left->left != right);
}
/查找ID的实现函数/
NODE *id_node(NODE *psthead, UINT32 u32Id)
{
NODE *left = psthead;
NODE *right = psthead;
do
{
left = left->left;
right = right->right;
if (left->student.numberu32Id)
return left;
if (right->student.numberu32Id)
return right;
} while (left != right && left->left != right);

return NULL;
1
}
/查找关键字函数/
VOID search_keywords(NODE psthead)
{
printf(“请输入需要查找的关键字:\n”);
char keyword[MAXNAMELENGTH];
scanf("%s", keyword);
keywords_node(psthead, keyword);
printf(" 查找的学生信息如下:\n");
printf("**************************************************************\n\n");
printf(" 学号\t\t姓名\t\t年龄\t\t成绩\n\n");
if(0==u32countKeywords)
{
printf(" 查无此人\n");
printf("***************************************************************\n");
return;
}
else
{
for(UINT32 i=0;i<u32countKeywords;i++)
{
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", stuKeywords[i].number, stuKeywords[i].name, stuKeywords[i].age,stuKeywords[i].score);
}
printf("***************************************************************\n");
u32countKeywords=0;
}
}
/查找关键字实现函数/
VOID keywords_node(NODE *psthead, CHAR keywords[MAXNAMELENGTH])
{
NODE *left = psthead;
NODE *right = psthead;
do
{
left = left->left;
right = right->right;
if (NULL!=strstr(left->student.name,keywords))
{
stuKeywords[u32countKeywords++]=left->student;
}
if (NULL!=strstr(right->student.name,keywords))
{
stuKeywords[u32countKeywords++]=right->student;
}
} while (left != right && left->left != right);

}
/查找链首尾函数/
VOID search_rh(NODE psthead)
{
printf(" 查找的学生信息如下:\n");
printf("**************************************************************\n\n");
printf(" 学号\t\t姓名\t\t年龄\t\t成绩\n\n");
printf(“链首:%d\t\t%s\t\t%d\t\t%d\t\t\n\n”, psthead->right->student.number, psthead->right->student.name, psthead->right->student.age,psthead->right->student.score);
printf(“链尾:%d\t\t%s\t\t%d\t\t%d\t\t\n\n”, psthead->left->student.number, psthead->left->student.name, psthead->left->student.age,psthead->left->student.score);
printf("***************************************************************\n\n");
}
/求双向循环链表的长度/
INT32 len_list(NODE *psthead)
{
NODE *p = psthead;
UINT32 u32len = 0;
while (p->right != psthead){
u32len++;
p = p->right;
}
return u32len;
}
/打印链表内容/
VOID print_list(NODE * psthead)
{
if(psthead->right==psthead)
{
printf(" 系统为空!\n");
return;
}
NODE *p = psthead->right;
printf(" 学号\t\t姓名\t\t年龄\t\t成绩\n\n");
while (p != psthead)
{
printf(" %d\t\t%s\t\t%d\t\t%d\t\t\n\n", p->student.number, p->student.name, p ->student.age, p->student.score);
p = p->right;
}
}
UINT32 u32count_number=0;/学号输错次数计数器/
VOID updata_Id(NODE *psthead , NODE *p)
{

 UINT32 u32inputNumber;
 printf("请输入学号(1000-10000之间):");
 while(0==scanf("%d",&u32inputNumber))/*scanf输入数字时返回1，否则返回0*/
 {
	 fflush(stdin);/*清理缓存*/
     printf("输入错误,请输入数字:");
 }
 UINT32 u32id=u32inputNumber;
if(u32inputNumber>=1000&&u32inputNumber<=10000)
{
	NODE *ID_NODE=id_node(psthead, u32id);
	if(ID_NODE==NULL)
	{
       p->student.number=u32id;
	   u32count_number=0;
	}
	else
	{
	   printf("该学号已经存在，请输入其他学号!\n\n");
	   updata_Id(psthead,p);
	}
}
else
{
	printf("输入错误,");
	if(u32count_number<2)
	 {
		  u32count_number++;
		  printf("您还有%d次输入机会!\n\n",3-u32count_number);
		  updata_Id(psthead,p);
	 }
	 else
	 {
		system("CLS");
        printf("您的错误次数已达3次,感谢您的使用，学生管理系统已经退出！\n\n");
        exit(0);
	 }
	
}

}
UINT32 u32count_age=0; /年龄输错次数计数器/
VOID updata_age( NODE *p)
{
UINT32 u32inputAge=0;
printf(“请输入年龄(5-60):”);
while(0scanf("%d",&u32inputAge))/scanf输入数字时返回1，否则返回0/
{
fflush(stdin);/清理缓存/
printf(“输入错误,请输入数字:”);
}
if(u32inputAge>=5&&u32inputAge<=60)/输入年龄需在16—70之间/
{
p->student.age=u32inputAge;
u32count_age=0;
}
else
{
printf(“输入错误，”);
if(u32count_age<2)
{
u32count_age++;
printf(“您还有%d次输入机会!\n\n”,3-u32count_age);
updata_age§;
}
else
{
system(“CLS”);
printf(“您的错误次数已达3次,感谢您的使用，学生管理系统已经退出！\n\n”);
exit(0);
}
}
}
UINT32 u32count_name=0; /名字输错次数计数器/
VOID updata_name( NODE *p)
{
CHAR inputName[NAMELENGTH];
printf(“请输入姓名(40字节之内):”);
scanf("%s",inputName);
if(strlen(inputName)<=40)/输入名字需在40个字符之内/
{
strcpy(p->student.name,inputName);
u32count_name=0;
}
else
{
printf(“输入错误,”);
if(u32count_name<2)
{
u32count_name++;
printf(“您还有%d次输入机会!\n\n”,3-u32count_name);
updata_name§;
}
else
{
system(“CLS”);
printf(“您的错误次数已达3次,感谢您的使用，学生管理系统已经退出！\n\n”);
exit(0);
}
}
}
UINT32 u32count_score=0;/成绩输错次数计时器/
VOID updata_score(NODE *p)
{
UINT32 u32inputScore;
printf(“请输入成绩(0-100):”);
while(0scanf("%d",&u32inputScore))/scanf输入数字时返回1，否则返回0/
{
fflush(stdin);/清理缓存/
printf(“输入错误,请输入数字:”);
}
if(u32inputScore>=0&&u32inputScore<=100)
{
p->student.score=u32inputScore;
u32count_score=0;
}
else
{
printf(“输入错误,”);
if(u32count_score<2)
{
u32count_score++;
printf(“您还有%d次输入机会!\n\n”,3-u32count_score);
updata_score§;
}
else
{
system(“CLS”);
printf(“您的错误次数已达3次,感谢您的使用，学生管理系统已经退出！\n\n”);
exit(0);
}
}

}
VOID updata_student(NODE *psthead )
{
while(1)
{
UINT32 u32id;
printf(“输入0返回上一层 （或） 输入要修改的学生学号:\n\n”);
scanf("%d",&u32id);
if(0u32id)
{
return;
}
NODE *pstSearch=id_node(psthead,u32id);
if(pstSearchNULL)
{
printf(“查无此学号，请重新输入学号:\n\n”);
scanf("%d",&u32id);
}
UINT32 u32repeatId;
NODE *p=id_node(psthead,u32id);
printf(“请输入要改正的信息：1->学号 2—>姓名 3->年龄 4—>成绩 5->返回上一层\n\n”);
INT32 input;
while(0==scanf("%d",&input))/scanf输入数字时返回1，否则返回0/
{
fflush(stdin);/清理缓存/
printf(“输入错误,请输入数字:”);
}
//scanf("%d",&input);
switch(input)
{
case 1:
updata_Id(psthead,p);
break;
case 2:
updata_name§;
break;
case 3:
updata_age( p);
break;
case 4:
updata_score§;
break;
case 5:
return ;
default:
printf("输入错误请重新输入: ");
updata_student(psthead);
}
}

}
VOID menu()
{
printf(" 菜单指令如下\n");
printf("*************************************************\n\n");
printf("---------------------- 1->添加学生信息 ----------------------\n\n");
printf("---------------------- 2->删除学生信息 ----------------------\n\n");
printf("---------------------- 3->查找学生信息 ----------------------\n\n");
printf("---------------------- 4->修改学生信息 ----------------------\n\n");
printf("---------------------- 5->显示菜单指令 ----------------------\n\n");
printf("---------------------- 6->排序(成绩降序/年龄升序)------------\n\n");
printf("---------------------- 7->退出管理系统 ----------------------\n\n");
printf("***************************************************************\n\n");
}
/排序/
VOID sort(NODE psthead, INT32 u32len)
{
while(1)
{
printf(“请输入排序方法：1-按成绩降序排序 2-按年龄升序排序 3-返回上一层:”);
UINT32 u32inputSort;
while(0==scanf("%d",&u32inputSort))/scanf输入数字时返回1，否则返回0/
{
fflush(stdin);/清理缓存/
printf(“输入错误,请输入数字:”);
}
switch(u32inputSort)
{
case 1:
score_sort(psthead, u32len);
printf("\n");
printf(" 学生信息管理系统\n");
printf("**************************************************************\n\n");
print_list(psthead);
printf("***************************************************************\n\n");
break;
case 2:
age_sort(psthead, u32len);
printf("\n");
printf(" 学生信息管理系统\n");
printf("***************************************************************\n\n");
print_list(psthead);
printf("***************************************************************\n\n");
break;
case 3:
return;
default:
printf(“输入错误，请重新输入：”);
sort(psthead, u32len);
break;
}
}
}
/按成绩降序排序的实现函数/
VOID score_sort(NODE *psthead, INT32 u32len)
{
NODE *p, *q, *max;
Student t;
p = psthead->right;
q = p->right;
INT32 i = 0, j = 0;
for (i = 0; i < u32len - 1; i++)
{
if (p == psthead)
break;
max = p;
q = p;
for (j = i; j < u32len; j++)
{
if (q == psthead)
break;
if (max->student.scorestudent.score)
max = q;
q = q->right;
}
if (max != p)
{
t = max->student;
max->student = p->student;
p->student = t;
}
p = p->right;
}
}
/按年龄升序排序的实现函数/
VOID age_sort(NODE *psthead, INT32 u32len)
{
NODE *p, *q, *min;
Student t;
p = psthead->right;
q = p->right;
UINT32 i = 0, j = 0;
for (i = 0; i < u32len -1; i++)
{
if (p == psthead)
break;
min = p;
q = p;
for (j = i; j < u32len; j++)
{
if (q == psthead)
break;
if (min->student.age>q->student.age)
min = q;
q = q->right;
}
if (min != p)
{
t = min->student;
min->student = p->student;
p->student = t;
}
p = p->right;
}
}
/按学号升序排序/
VOID id_sort(NODE *psthead, INT32 u32len)
{
NODE *p, *q, *min;
Student t;
p = psthead->right;
q = p->right;
UINT32 i = 0, j = 0;
for (i = 0; i < u32len -1; i++)
{
if (p == psthead)
break;
min = p;
q = p;
for (j = i; j < u32len; j++)
{
if (q == psthead)
break;
if (min->student.number>q->student.number)
min = q;
q = q->right;
}
if (min != p)
{
t = min->student;
min->student = p->student;
p->student = t;
}
p = p->right;
}
}

dataType.h头文件如图所示
#ifndef data_type_H
#define data_type_H
typedef char INT8;
typedef unsigned char UINT8;
typedef short INT16;
typedef unsigned short UINT16;
typedef int INT32;
typedef unsigned int UINT32;
typedef long long INT64;
typedef unsigned long long UINT64;
typedef bool BOOL;
typedef char CHAR;
typedef char* STRING;
typedef void VOID;
typedef float FLOAT;
typedef double DOUBLE;
#endif

student.h头文件如图所示
#ifndef student_H
#define student_H
#include "dataType.h"
#define MAXNAMELENGTH 20
#define MAXAGELENGTH 100
#define KEYWORDSLENGTH 100
#define RANDNUMBER 1000
#define RANDNUMBERC 26
#define NAMELENGTH 100
typedef struct SNODE{
	UINT32 number;
    CHAR  name[MAXNAMELENGTH];
	UINT32 age;
    UINT32 score;
}Student;
typedef struct NODE{
    Student student;
    struct NODE *left;
    struct NODE *right;
}NODE;
NODE *create_list();/*创建双向循环链表*/
VOID init_list(NODE *psthead);/*初始化链表*/
INT32 insert_student(NODE *psthead);/*插入函数*/
INT32 insert_list(NODE *psthead, Student newStudent);/*插入实现函数，头插法插入结点*/
VOID search(NODE *psthead);/*查找总函数*/
NODE *id_node(NODE *psthead, UINT32 ID);/*查找学号实现函数*/
VOID search_age(NODE *psthead);/*查找年龄函数*/
VOID age_node(NODE *psthead, UINT32 ageMin,UINT32 ageMax);/*查找年龄实现函数*/
VOID search_score(NODE *psthead);/*查找成绩函数*/
NODE *score_node(NODE *psthead, UINT32 u32ScoreMin, UINT32 u32ScoreMax);/*查找成绩实现函数*/
VOID search_name(NODE *psthead);/*查找函数*/
VOID all_name_node(NODE *psthead, CHAR *studentName);/*查找指定的全部名字*/
NODE *name_node(NODE *psthead, CHAR *name);/*查找名字实现函数*/
VOID search_keywords(NODE *psthead);/*查找关键字函数*/
VOID keywords_node(NODE *psthead, CHAR keywords[20]);/*查找关键字实现函数*/
VOID search_rh(NODE *psthead);/*查找链首尾函数*/
INT32  delete_student(NODE *psthead);/*删除函数*/
INT32 delete_node(NODE *psthead, CHAR *name);/*删除指定姓名*/
INT32  delete_id(NODE *psthead, UINT32 u32Id);/*删除指定学号*/
VOID delete_all_node(NODE *psthead);/*删除全部学生实现函数*/
VOID updata_student(NODE *psthead);/*修改函数*/
INT32 len_list(NODE *psthead);/*求双向循环链表的长度*/
VOID print_list(NODE * psthead);/*打印链表内容*/
VOID sort(NODE *psthead, INT32  u32len);/*排序函数*/
VOID age_sort(NODE *psthead, INT32  u32len);/*按照年龄升序排序函数*/
VOID score_sort(NODE *psthead, INT32  u32len);/*按照成绩降序排序函数*/
VOID id_sort(NODE *psthead, INT32  u32len);/*按照学号升序排序函数*/
VOID menu();/*初始化15个学生*/
VOID updata_Id(NODE *psthead, NODE *p);/*学号输入判断函数*/
VOID updata_name(NODE *p);/*姓名输入判断函数*/
VOID updata_age(NODE *p);/*年龄输入判断函数*/
VOID updata_score(NODE *p);/*分数输入判断函数*/
UINT32 u32countAge=0;
UINT32 u32countScore=0;
Student stuAge[ MAXAGELENGTH];
UINT32 u32countKeywords=0;
Student stuKeywords[KEYWORDSLENGTH];
#endif
你想要怎么样的人生？
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用单向循环链表实现学生管理系统7.22(分文件 C语言)
qq_60071225的博客
07-22 446
利用单向循环链表实现学生管理系统的增删改查功能的代码，利用linux并使用分文件实现。
基于双向循环链表实现的学生教务管理系统.rar
09-12
综上所述，这个基于双向循环链表的教务管理系统项目不仅涵盖了数据结构和算法的运用，还涉及到软件设计的多个层面，是学习和提升编程技能的良好实践。通过实际操作和优化，我们可以深入理解数据结构的特性，并将其...
双向循环链表实现—通讯录（学生管理系统，自行车管理系统，影院管理系统）—C语言课设（万能模板）—数据结构—用文件存储数据
普通大学生的博客
02-11 3250
双向循环链表实现，课设万能模板，通讯录，学生管理系统，自行车管理系统，影院管理系统......均可用
【数据结构】使用双向链表实现的学生信息管理系统（课程设计）
沅的博客
09-10 2035
期末课程设计要求 程序代码： 运行截图： //writing by ZYR //2021-6-25&&26 #include<iostream> #include<string.h> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef struct student { char name[20]; int score; char StuNum[10]; }
学生管理系统——基于双向循环链表
weixin_34248023的博客
09-03 239
2019独角兽企业重金招聘Python工程师标准>>> ...
使用双链表完成学生管理系统
子歌的博客
04-18 799
欢迎交流，共同进步。 题目为：学生信息管理系统 使用双链表机制，实现功能如下：插入一个学生数据、删除一个学生数据、修改一个学生数据、查找一个学生数据、遍历显示学生数据、导入表格数据、导出表格数据 。 #include<stdio.h> //标准IO #include<stdlib.h> //标准库 #include<stri...
数据结构--链表（学生信息管理系统）
梓川枫的博客
12-20 2101
双向链表的学生信息管理系统
初学者用链表实现学生管理系统
04-10
链表分为单链表、双向链表和循环链表等类型，其中单链表是最基本的形式，每个节点只有一个指向后继节点的指针。在学生管理系统中，我们可以用链表来存储学生的信息，每个节点代表一个学生，节点内容包括学号、姓名、...
双向循环链表实现学生分数管理系统
12-03
本项目“双向循环链表实现学生分数管理系统”旨在通过C语言，利用双向循环链表的数据结构来设计一个简易的学生分数管理程序。下面我们将深入探讨这个系统的核心知识点。 1. **双向循环链表**： 双向链表与单链表...
基于链表的学生管理系统
06-26
链表分为单链表、双向链表和循环链表等不同类型，本项目可能使用了单链表，因为它是最基本且易于实现的链表形式。 在学生管理系统中，链表用于存储学生信息。每个节点代表一个学生，包含学生的各项属性，如学号、...
数据结构双向链表学生成绩管理系统
08-26
利用数据结构构建双向链表实现了学生成绩管理，管理包括对学生成绩的相关操作，如双向查找，添加，删除，排序，输出等多种功能。
基于线性表的图书管理系统 源代码 顺序表&链表
05-31
基于线性表的图书管理系统，《数据结构（C语言版 第2版）》严蔚敏 实验一
C语言实现 学生信息管理系统 双链表
08-20
STMS学生信息管理系统； 采用C语言、由双链表实现，有学生、老师、管理员三种角色登陆，每种角色权限功能不一样。
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
最新发布
09-20
在本项目中，我们利用C语言构建了一个航空信息查询系统，该系统的核心数据结构是双向循环链表。双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。...
双链表嵌套的简单学生信息管理系统
zhuguanlin121的博客
04-09 744
摘自：实现双链表嵌套的简单学生信息管理 作者：三速何时sub20 发布时间： 2020-07-20 10:44:40 网址：https://blog.csdn.net/weixin_44234294/article/details/107458155?spm=1001.2014.3001.5501 题目 链表A，每个节点存放一个新的链表B1，B2,B3,B4,B5的头结点。 场景：一个年级，相当链表A 该年级5个班，每个班5个人，相当于链表B1–B5 做一个学生成绩管理系统 学生成绩有语文 数学 英语 .
链表实现学生管理系统
jolly0514的博客
08-17 1889
/*设计一个完整的程序，根据用户输入的学生人数n(n>=3)及每个学生姓名和成绩建立一个单链表， 并按照学生成绩递减排序，然后按照名次输出所有学生的姓名和成绩*/ #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include <string.h> #include<stdlib.h> struct student { char name[20]; int math; int num; }; //.
单链表建立学生成绩
CHENCHWT的博客
04-30 1734
#include &lt;iostream&gt;using namespace std;  const int M=100;  struct Node  {          int data;          Node *next;  };class LinkList              {      public:          LinkList();          Link...
c/c++笔试
热门推荐
hcdzhi的专栏
12-03 1万+
1．进程和线程的差别。线程是指进程内的一个执行单元,也是进程内的可调度实体.与进程的区别:(1)调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位(2)并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行(3)拥有资源：进程是拥有资源的独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源. (4)系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导
掌握双向循环链表：数据结构基础
本资源是一份详细的数据结构讲义，主要针对双向循环链表进行图示讲解，属于数据结构课程的核心内容。主讲者是具有副教授职称的专业讲师，课程设计包括理论教学和实践操作，共计84学时，涵盖了基本概念、线性结构（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值