精华内容
下载资源
问答
  • 利用数据结构构建双向链表实现了学生成绩管理管理包括对学生成绩的相关操作,如双向查找,添加,删除,排序,输出等多种功能。
  • C++ 双向链表实现学生管理系统
  • 完成双向链表的插入、删除以及查找,将学生管理系统使用的数组,以双向链表的方式实现,能够支持无限制的学生人数的增删改查以及保存。 3,代码实现。 #include #include #include #include typedef struct ...
  • 题目要求 ...4:老师可以增加或者删除学生 5:学生只可以查看自己的成绩 6:老师可以查看所有学生的成绩,以及修改本科的成绩 #include<stdio.h> #include<stdlib.h> #include<stdbool.h...

    题目要求
    1:要求有登陆功能
    2:成员信息:学号,语数外成绩,账号,密码,性别,身份(老师还是学生),以及地址
    3:老师和学生都可以修改自己的密码
    4:老师可以增加或者删除学生
    5:学生只可以查看自己的成绩
    6:老师可以查看所有学生的成绩,以及修改本科的成绩

    #include<stdio.h>
    #include<stdlib.h>
    #include<stdbool.h>
    #include<string.h>
    typedef struct node
    {
    	int id_num;//teacher or student's number
    	char status;//teacher : t , student : s
    	int chinese;
    	int math;
    	int English;
    	int passwd;
    	char address[64];
    	char sex;//man : m , women : w
    	struct node *next;
    }*listnode;
    
    listnode listnode_init()
    {
    	listnode head = malloc(sizeof(struct node)); //申请头结点空间
    	if(head == NULL)
    	{
    		perror("list init error");
    		return NULL;
    	}
    	head->next = NULL;
    	return head;//返回头结点地址
    }
    
    void data_init(listnode newnode ,int id_num,char status,int chinese,int math ,int English , int passwd,char * address,char sex)
    {
    	newnode->id_num = id_num;
    	newnode->status = status;
    	newnode->chinese = chinese;
    	newnode->math = math;
    	newnode->English = English;
    	newnode->passwd = passwd;
    	strcpy(newnode->address,address);
    	newnode->sex = sex;
    }
    
    bool add_node(listnode head,int id_num,char status,int chinese,int math ,int English , int passwd,char * address,char sex)
    {
    	listnode newnode = malloc(sizeof(struct node));
    	if(newnode == NULL)
    	{
    		perror("malloc newnode error");
    		return -1;
    	}
    	//2、初始化节点数据
        data_init(newnode ,id_num,status,chinese,math ,English,passwd,address,sex);
        	
    	//3找到链表尾部
    	listnode p = head;
    	while(p->next != NULL)  //如果p->next不等于 NULL,证明后面还有节点
    	{
    		p = p->next;	
    	}
    	newnode->next = p->next;
    	p->next = newnode;	
    	printf("尾插法所接入的数据 %d,%c\n", p->next->id_num,p->next->status);
        return 0;
    }
    
    listnode search_member_prev(listnode head ,int id_number)
    {
    	listnode tmp = head ;
    	while(tmp->next != NULL)
    	{
    		if(tmp->next->id_num == id_number)
    		{
    			return tmp ;
    		}	
            tmp = tmp->next;		
    	}
    	return NULL;
    }
    
    //传入头节点,和另一个节点
    //函数中输入 id_num 和 passwd,若匹配,返回true
    listnode login_in(listnode head,listnode newOne)
    {
    	int passwdInput,id_num;
    	listnode new = head;
    	printf("please input your id_num(five Number): ");
    	if(scanf("%d",&(id_num)) == 1)
    	{
    		while(getchar() != '\n');
    		listnode tmp = search_member_prev(head,id_num);
    	    if(tmp != NULL)
    		{
    			printf("please input your password :");
    			scanf("%d",&passwdInput);
    			while(getchar() != '\n');
    			if(tmp->next->passwd == passwdInput)
    			{
    				newOne = tmp;
    				return newOne;
    			}
    		}
    	}
    	return NULL;
    }
    
    int JudgeStuTea(listnode head ,listnode newOne)
    {
    	printf("1");
    	int number = newOne->next->id_num ;
    	listnode tmp = search_member_prev(head,number);
    	if( tmp->next->status == 't')
    	{
    		printf("this is a teacher\n");
    		return 1;
    	}
    	else
    		return 0;
    }
    
    void show_grade(listnode newOne)
    {
    	printf("                                     %d \n",         newOne->next->id_num);
    	printf("                                     chinese : %d\n",newOne->next->chinese);
    	printf("                                     math    : %d\n",newOne->next->math);
    	printf("                                     English : %d\n\n",newOne->next->English);
    }
    //修改密码
    bool alter_passwd(listnode newOne)
    {
    	char Judge;
    	int passwd;
    	printf("your password : %d\n",newOne->next->passwd);
    	printf("You are sure about changing Your pasword ? y/n : \n");
        scanf("%c",&Judge);
    	while(getchar()!='\n');
    	if(Judge == 'y')
    	{
    		printf("please input your new password :\n");
    		scanf("%d",&passwd);
    		newOne->next->passwd = passwd;
    		printf("%d\n",newOne->next->passwd);
    	    return true;
    	}
    	else
    	{
    		printf("don't waste my time , bitch !\n");
    		return false;
    	}
    }
    
    //学生操作
    void StuMove(listnode head , listnode newOne)
    {
    	int numberOption;
    	while(1)
    	{
    		printf(" hello ,%d \n",newOne->next->id_num);
    		printf(" press 0 : show your all grade \n\n");
    		printf(" press 1 : alter your passwd \n\n\n");
    		printf(" press 2 : exit\n\n");
    		printf(" Your option : \n");
    		scanf("%d",&numberOption);
    		while(getchar() != '\n');
    		switch(numberOption)
    		{
    			case 0:
    			    show_grade(newOne);
    				break;
    			case 1:
    			    alter_passwd(newOne);
    				break;
    			case 2:
    			    return;
    		}
    	}
    }
    
    //打印所有的成员信息
    void show_all(listnode head)
    {
    	listnode tmp = head;
    	while(tmp->next != NULL)
    	{
    		printf("\tI\tS\tC\tM\tE\tA\t\tSEX\n\n");
    		printf("\t%d\t%c\t%d\t%d\t%d\t%s\t%c\t\n\n",tmp->next->id_num,tmp->next->status,tmp->next->chinese,tmp->next->math ,tmp->next->English ,tmp->next->address,tmp->next->sex);
    	    tmp = tmp->next;
    	}
    }
    
    listnode add_grades(listnode head)
    {
    	listnode tmp = head;
    	char addressInput[20];
    	
    	while(tmp->next != NULL)
    	{
    		tmp = tmp->next;
    	}
    	listnode new  = malloc(sizeof(struct node));
    	printf("\n\n");
    	printf("please input the student 's id : ");
    	scanf("%d",&(new->id_num));
    	while(getchar() != '\n');
    	printf("\n\n");
    	new->status = 's';
    	printf("please input the student 's chinese : ");
    	scanf("%d",&(new->id_num));
    	while(getchar() != '\n');
    	printf("\n\n");
    	printf("please input the student 's math : ");
    	scanf("%d",&(new->math));
    	while(getchar() != '\n');
    	printf("\n\n");
    	printf("please input the student 's English : ");
    	scanf("%d",&(new->English));
    	while(getchar() != '\n');
    	printf("\n\n");
    	printf("please input the student 's passwd : ");
    	scanf("%d",&(new->passwd));
    	while(getchar() != '\n');
    	printf("\n\n");
    	printf("please input the student 's address : ");
    	gets(addressInput);
    	strcpy(new->address,addressInput);
    	printf("\n\n");
    	printf("please input the student 's sex : ");
    	scanf("%c",&(new->sex));
    	while(getchar() != '\n');
    	tmp->next = new;
    	show_all(head);
    	return head;
    }
    
    //修改学生信息
    bool alter_grades(listnode head,listnode newOne)
    {
    	int id_num,grade,subject,judgeStu,teaSubject = 0;
    	printf("please input the student's id_num :");
        scanf("%d",&id_num);
    	while(getchar() != '\n');
    	listnode tmp = search_member_prev(head ,id_num);
    	//根据id_num在学生列表中匹配学生,若匹配成功,且该id_num不是一个老师 tmp->next->status != 't'
    	//则进行下一步操作
    	if( ( tmp != NULL ) && (tmp->next->status != 't'))
    	{
    		printf("is he this guy ?(y:1,n:0)\n");
    		show_grade(tmp);
    		scanf("%d",&judgeStu);
    		while(getchar()!='\n');
    		if(judgeStu == 1)
    		{
    			//这里匹配登陆账号老师是教哪一科的,从而修改具体学生哪一科的成绩
    			if(newOne->next->math == -1)
    			{
    				printf(" how much about math : ");
    				scanf("%d",&(tmp->next->math));
    				show_grade(tmp);
    				return true;
    			}
    			else
    			    if(newOne->next->chinese == -1)
    			{
    				printf(" how much about chinese : ");
    				scanf("%d",&(tmp->next->chinese));
    				show_grade(tmp);
    				return true;
    			}
    			else 
    				if(newOne->next->English == -1)
    			{
    				printf(" how much about English : ");
    				scanf("%d",&(tmp->next->English));
    			    show_grade(tmp);
    				return true;
    			}
    				
    		}
    	}
    	return false;
    	
    }
    
    //学生删除操作 参数:一个listnode 的头节点
    void student_delete(listnode head)
    {
    	int id_number,judgeStu;
    	listnode tmp = head;
    	listnode disap;
    	printf("who , delete :");
    	scanf("%d",&id_number);
    	//根据输入寻找学生,
    	tmp = search_member_prev(head ,id_number);
    	if(tmp != NULL)
    	{
    		printf("is he this guy ?(y:1,n:0)\n");
    		show_grade(tmp);
    		scanf("%d",&judgeStu);
    		if(judgeStu == 1)
    		{
    			disap = tmp->next;
    			tmp->next = tmp->next->next;
    			free(disap);	
    			show_all(head);
    			printf("delete student successfully");
    		}
    		else
    		{
    			printf("delete failed");
    		}
    	}
    }
    
    
    //老师操作选项
    //根据输入选择老师可以进行的功能
    void TeaMove(listnode head,listnode newOne)
    {
    	int options;
    	while(1)
    	{
    		printf(" welcome , %d",newOne->next->id_num);
    		printf(" press 0 : change your passwd\n");
    		printf(" press 1 : show the all grades\n");
    		printf(" press 2 : alter one student's grades\n");
    		printf(" press 3 : delete one student\n");
    		printf(" press 4 : add one student\n");
    		printf(" press 5 : exit\n\n");
    		scanf("%d",&options);
    		while(getchar()!= '\n');
    			switch(options)
    			{
    				case 0:
    					alter_passwd(newOne);
    					break;
    				case 1:
    					show_all(head);
    					break;
    				case 2:
    					alter_grades(head,newOne);
    					break;
    				case 3:
    					student_delete(head);
    					break;
    				case 4:
    				    head = add_grades(head);
    					break;
    				case 5:
    					return;
    			}
    		}
    }
    
    
    int main()
    {
    	//先插入几个学生和老师的信息
    	listnode head = listnode_init();
    	add_node(head,20161,'t',-1,0,0,123456,"hubeijinghzou",'w');
    	add_node(head,20162,'t',0,-1,0,123457,"hubeiwuhan",'m');
    	add_node(head,20163,'t',0,0,-1,123458,"hubeixiaogan",'m');
    	add_node(head,20164,'s',59,60,61,123459,"hubeijingzhou",'w');
    	add_node(head,20165,'s',79,73,77,123450,"hubeijingzhou",'m');
    	add_node(head,20166,'s',99,83,87,223450,"hubeijingzhou",'m');
    	//验证登陆信息
    	listnode newOne = head->next;
    	while(1)
    	{
    		newOne = login_in(head,newOne);
    		if(newOne != NULL)
    			break;
    	}
    	//欢迎界面
    	printf("welcome to zhangke's school info manage system :\n\n");
    	//进行判断,如果是老师,进入 TeaMove
    	//如果是学生,进入StuMove
    	if( JudgeStuTea(head,newOne) == 1 )
    		TeaMove(head,newOne);
    	else
    		StuMove(head,newOne);
    	
    }
    
    

    思路:
    1 登陆:我们需要实现登陆功能,我的做法是程序运行时,我先初始化链表,然后插入几个成员信息,包括学生和老师的,(这在主函数的 add_node中可以看到插入了6个成员),你也可以改变思路:初始化链表之后,先进行 add_grades() (即添加成员,再进行登陆程序),
    2 老师:在老师的设定上,我采取了这样的方法,老师没有语数外成绩,教哪一科就将哪一科的成绩设定为-1,登陆监测到是老师就进行Tea_move,然后一个死循环,中间加switch(),对输入的功能选项进行选择,这里,老师查看成绩时,调用的是show_all
    3 学生没什么好说的,只有查看成绩时,调用show_grades
    4,链表这一块,掌握最基本的增删改查就可以了,然后进行一些练习,在调试程序的时候多加一些priintf();才能更好的查看错误以及程序的运行情况,否则,程序运行报错只有一个段错误,真的惨

    展开全文
  • 老师布置的课设作业,要求用双向链表实现学生信息管理系统,学生信息包括学号,姓名,年龄,入学日期,电话等,实现增删改操作。。大神教教我吧,c++和java都可以,拜托![图片说明]...
  • 摘自:实现双链表嵌套的简单学生信息管理 作者:三速何时sub20 发布时间: 2020-07-20 10:44:40 网址:https://blog.csdn.net/weixin_44234294/article/details/107458155?spm=1001.2014.3001.5501 题目 链表A,每...

    参考:实现双链表嵌套的简单学生信息管理
    作者:三速何时sub20
    发布时间: 2020-07-20 10:44:40
    网址:https://blog.csdn.net/weixin_44234294/article/details/107458155?spm=1001.2014.3001.5501

    参考:双链表嵌套实现简单学生成绩管理系统
    作者:0~∞
    发布时间: 2021-06-14 22:43:56
    网址:https://blog.csdn.net/m0_47561451/article/details/117913579?spm=1001.2014.3001.5501

    题目

    场景:一个年级,相当于链表A,该年级5个班,每个班5个人,相当于链表B1–B5。功能:录入学生基本信息和成绩,找出最高分、最低分、平均分。

    思路

    这个系统是一个双链表系统(班级和学生),母链表(班级)的每一个节点包含一个子链表(学生)的头节点,可以根据这个思想来创建(头插法、尾插法)和遍历链表,核心就是建立好这个双链表,其他的可以根据遍历链表来找出最高分、最低分、平均分。如图:
    在这里插入图片描述

    参考代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //函数的声明(先定义的函数先使用了 可以不用声明)
    struct Class *ClassMessage(struct Class *head,int Classnum,int stunum);
    struct student *stuMessage(struct student *head,int stunum,int Classnum);
    struct student *insertStuMessage(struct student *head,struct student *newData2);
    void printMessage(struct Class *head,int stunum,int Classnum);
    void findMathMaxScore(struct Class *head,int Classnum,int stunum);
    void findChineseMaxScore(struct Class *head,int Classnum,int stunum);
    void findEnglishMaxScore(struct Class *head,int Classnum,int stunum);
    void gradeAvg(struct Class *head,int Classnum,int stunum);
    
    //学生信息结构体
    struct student
    {
        int data;
        int chinese;
        int math;
        int english;
        int sum;
        float avg;
        struct student *next;
    };
    //班级结构体
    struct Class
    {
        int ClassNum;
        struct student *messageHead;//定义一个结构体指针指向学生信息链表
        struct Class *next;
    };
    
    
    
    //1、班级和学生链表(嵌套)创建
    struct Class *ClassMessage(struct Class *head,int Classnum,int stunum)
    {
       
        int j;
        struct Class *p=head;
        struct Class *newData=NULL;//用来新建信息的班级
        struct student *stuHead;   
        for(j=0;j<Classnum;j++){   //班级链表的创建
            newData=(struct Class *)malloc(sizeof(struct Class));
            newData->ClassNum = j+1;                                             //班级链表的内容
            stuHead=stuMessage(stuHead,stunum,j+1);//嵌套创建学生链表
            newData->messageHead=stuHead;                                        //班级链表的内容
           
            printf("#######################################\n");
             if(p == NULL){
                head = newData;
            }else{
                
                    newData->next=head;//头插法                                  //班级链表的内容
                    head=newData;
            }
        
        }
        return head;
    }
    
    //录入一个学生信息
    struct student *stuMessage(struct student *head,int stunum,int Classnum)
    {
        int i;
        int sum;
        float avg;
        struct student *newData;
        for(i=0;i<stunum;i++){
            newData=(struct student *)malloc(sizeof(struct student));
            printf("请输入%d班第%d位学生学号\n",Classnum,i+1);
            scanf("%d",&(newData->data));
            printf("chinese:\n");
            scanf("%d",&(newData->chinese));
            printf("math:\n");
            scanf("%d",&(newData->math));
            printf("english:\n");
            scanf("%d",&(newData->english));
            newData->sum=newData->chinese+newData->math+newData->english;
            newData->avg=(float)newData->sum/3;
    
            head=insertStuMessage(head,newData);//调用上面的头插法函数新建学生信息
        }
        return head;
    
    
    }
    
    
    //头插法插入到学生信息链表
    struct student *insertStuMessage(struct student *head,struct student *newData2)
    {
        if(head == NULL){
            head=newData2;
        }else{
            newData2->next=head;
            head=newData2;
        }
        return head;
    
    }
    
    //2、班级和学生链表的遍历打印
    void printMessage(struct Class *head,int stunum,int Classnum)
    {
        int i;
        int j;
        struct Class *p=head;//本来的链表头复制一份给P 用来自增遍历链表 这样就不会改变原有的链表形态
        struct student *p2=NULL;
        for(i=0;i<Classnum;i++){
           p2=p->messageHead;//让p2指向class结构体里面指向学生信息的指针
            for(j=0;j<stunum;j++){
                printf("第%d班第%d个学生:学号 %d\n",p->ClassNum,j+1,p2->data);
                printf("成绩:chinese:%d math:%d english:%d \n",p2->chinese,p2->math,p2->english);
                printf("总分:%d 平均分:%f\n",p2->sum,p2->avg);
                printf("---------------------------------\n");        
                p2=p2->next;
            }
            p=p->next;
    
        }
        
    
    }
    
    
    //3、链表遍历找数学最高分的学生
    void findMathMaxScore(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int maxScore=0;
        int stuHao;
        int classHao;
        int i;
        int j;
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                if(maxScore < pstu->math){
                    maxScore=pstu->math;
                    classHao=pclass->ClassNum;
                    stuHao=pstu->data;
                }
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        printf("-------------年级数学最高分--------------\n");
        printf("数学最高分是: %d班 学号 %d 分数 %d分\n",classHao,stuHao,maxScore);
    
    }
    
    //4、链表遍历找语文最高分的学生
    void findChineseMaxScore(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int maxScore=0;
        int stuHao;
        int classHao;
        int i;
        int j;
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                if(maxScore < pstu->chinese){
                    maxScore=pstu->chinese;
                    classHao=pclass->ClassNum;
                    stuHao=pstu->data;
                }
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        printf("---------------年级语文最高分--------------\n");
        printf("语文最高分是: %d班 学号 %d 分数 %d分\n",classHao,stuHao,maxScore);
    
    }
    
    //5、链表遍历找英语最高分的学生
    void findEnglishMaxScore(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int maxScore=0;
        int stuHao;
        int classHao;
        int i;
        int j;
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                if(maxScore < pstu->english){
                    maxScore=pstu->english;
                    classHao=pclass->ClassNum;
                    stuHao=pstu->data;
                }
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        printf("---------------年级英语最高分--------------\n");
        printf("英语最高分是: %d班 学号 %d 分数 %d分\n",classHao,stuHao,maxScore);
    
    }
    
    //6、链表遍历计算年级均分
    void gradeAvg(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int gradeSum=0;
        int numOfStu;
        float gradeAvg;
        int i;
        int j;
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                numOfStu++;
                gradeSum+=pstu->sum; 
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        gradeAvg=(float)gradeSum/numOfStu;
        printf("---------------年级平均分--------------\n");
        printf("年级平均分是%f\n",gradeAvg);
    }
    int main()
    {
        int a;
        int b;
        struct Class *head;            //其实也是个野指针
        printf("请输入班级数量:\n");
        scanf("%d",&a);
        printf("请输入班级人数量:\n");
        scanf("%d",&b);
        head=ClassMessage(head,a,b);   //1、班级、学生链表的创建
        printMessage(head,b,a);        //2、班级、学生链表的遍历打印
        findMathMaxScore(head,a,b);    //3、数学最高
        findChineseMaxScore(head,a,b); //4、语文最高
        findEnglishMaxScore(head,a,b); //5、英语最高
        gradeAvg(head,a,b);            //6、年级均分
       
        system("pause");
        return 0;
    }
    

    运行结果

    仔细观察,链表遍历输出学生信息的时候,发现遍历的顺序是从2班学号为2的学生开始往后遍历的,这是因为我们使用的是头插法创建链表,最后插入到链表的最先被遍历。

    请输入班级数量:
    2
    请输入班级人数量:
    2
    请输入1班第1位学生学号
    1
    chinese:
    87
    math:
    90
    english:
    45
    请输入1班第2位学生学号
    2
    chinese:
    78
    math:
    54
    english:
    67
    #######################################
    请输入2班第1位学生学号
    1
    chinese:
    56
    math:
    89
    english:
    54
    请输入2班第2位学生学号
    2
    chinese:
    76
    math:
    89
    english:
    56
    #######################################
    第2班第1个学生:学号 2
    成绩:chinese:76 math:89 english:56
    总分:221 平均分:73.666664
    ---------------------------------
    第2班第2个学生:学号 1
    成绩:chinese:56 math:89 english:54
    总分:199 平均分:66.333336
    ---------------------------------
    第1班第1个学生:学号 2
    成绩:chinese:78 math:54 english:67
    总分:199 平均分:66.333336
    ---------------------------------
    第1班第2个学生:学号 1
    成绩:chinese:87 math:90 english:45
    总分:222 平均分:74.000000
    ---------------------------------
    -------------年级数学最高分--------------
    数学最高分是: 1班 学号 1 分数 90分
    ---------------年级语文最高分--------------
    语文最高分是: 1班 学号 1 分数 87分
    ---------------年级英语最高分--------------
    英语最高分是: 1班 学号 2 分数 67分
    ---------------年级平均分--------------
    年级平均分是140.166672
    请按任意键继续. . .
    

    问题探索

    在学生结构体体面添加 char *name,用来曾加学生的名字信息,可是遍历结果体的时候就出现段错误。
    学生结构体的地方
    在这里插入图片描述
    录入的地方
    在这里插入图片描述
    遍历的地方
    在这里插入图片描述

    感谢大佬指点了一下,加了名字的代码如下

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    //学生信息结构体
    struct student
    {
        int data;
        char name[10];
        int chinese;
        int math;
        int english;
        int sum;
        float avg;
        struct student *next;
    };
    //班级结构体
    struct Class
    {
        int ClassNum;
        struct student *messageHead;//定义一个结构体指针指向学生信息链表
        struct Class *next;
    };
    //打印各个学生的相关信息
    void printMessage(struct Class *head,int stunum,int Classnum)
    {
        int i;
        int j;
        int k=1;//用来计算第几个学生的
        struct Class *p=head;
        struct student *p2=NULL;
        for(i=0;i<Classnum;i++){
           p2=p->messageHead;//让p2指向class结构体里面指向学生信息的指针
            for(j=0;j<stunum;j++){
                printf("第%d班第%d个学生:学号 %d 姓名:%s\n",p->ClassNum,k,p2->data,p2->name);
                printf("成绩:chinese:%d math:%d english:%d \n",p2->chinese,p2->math,p2->english);
                printf("总分:%d 平均分:%f\n",p2->sum,p2->avg);
                printf("---------------------------------\n");
                k++;
                p2=p2->next;
            }
            k=1;
            p=p->next;
    
        }
        
    
    }
    //使用头插法插入新的学生信息
    struct student *insertStuMessage(struct student *head,struct student *newData2)
    {
        if(head == NULL){
            head=newData2;
        }else{
            newData2->next=head;
            head=newData2;
        }
        return head;
    
    }
    //录入学生的相关信息
    struct student *stuMessage(struct student *head,int stunum,int Classnum)
    {
        int i;
        int num=stunum;
        int sum;
        float avg;
        struct student *newData;
        for(i=0;i<stunum;i++){
            newData=(struct student *)malloc(sizeof(struct student));
            printf("请输入%d班第%d位学生学号\n",Classnum,num);
            scanf("%d",&(newData->data));
            printf("请输入姓名:\n");
            scanf("%s",newData->name);
            printf("chinese:\n");
            scanf("%d",&(newData->chinese));
            printf("math:\n");
            scanf("%d",&(newData->math));
            printf("english:\n");
            scanf("%d",&(newData->english));
            sum=newData->chinese+newData->math+newData->english;
            newData->sum=sum;
            avg=(float)sum/3;
            newData->avg=avg;
            num--;
            head=insertStuMessage(head,newData);//调用上面的头插法函数新建学生信息
        }
        return head;
    
    
    }
    //班级链表的操作
    struct Class *ClassMessage(struct Class *head,int Classnum,int stunum)
    {
       
        int j;
        int num=Classnum;
        struct Class *p=head;
        struct Class *newData=NULL;//用来新建信息的班级
        struct student *stuHead;
        for(j=0;j<Classnum;j++){
            newData=(struct Class *)malloc(sizeof(struct Class));
            newData->ClassNum=num;
            stuHead=stuMessage(stuHead,stunum,num);
            newData->messageHead=stuHead;
           
            printf("#######################################\n");
            num--;
             if(p == NULL){
                head = newData;
            }else{
                
                    newData->next=head;
                    head=newData;
            }
            //newData=newData->next;
        
        }
        return head;
    }
    //找数学最高分的学生
    void findMathMaxScore(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int maxScore=0;
        int stuHao;
        int classHao;
        int i;
        int j;
        char *name;
        name = (char *)malloc(10);
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                memset(name,0,10);
                if(maxScore < pstu->math){
                    maxScore=pstu->math;
                    classHao=Classnum;
                    stuHao=pstu->data;
                    name=pstu->name;
                }
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        printf("-------------年级数学最高分--------------\n");
        printf("数学最高分是: %d班 学号 %d 姓名 %s 分数 %d分\n",classHao,stuHao,name,maxScore);
    
    }
    
    void findChineseMaxScore(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int maxScore=0;
        int stuHao;
        int classHao;
        int i;
        int j;
        char *name;
        name = (char *)malloc(10);
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                memset(name,0,10);
                if(maxScore < pstu->chinese){
                    maxScore=pstu->chinese;
                    classHao=pclass->ClassNum;
                    stuHao=pstu->data;
                    name=pstu->name;
                }
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        printf("---------------年级语文最高分--------------\n");
        printf("语文最高分是: %d班 学号 %d 姓名 %s 分数 %d分\n",classHao,stuHao,name,maxScore);
    
    }
    void findEnglishMaxScore(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int maxScore=0;
        int stuHao;
        int classHao;
        int i;
        int j;
        char *name;
        name = (char *)malloc(10);
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                memset(name,0,10);
                if(maxScore < pstu->english){
                    maxScore=pstu->english;
                    classHao=pclass->ClassNum;
                    stuHao=pstu->data;
                    name=pstu->name;
                    
                }
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        printf("---------------年级英语最高分--------------\n");
        printf("英语最高分是: %d班 学号 %d 姓名 %s 分数 %d分\n",classHao,stuHao,name,maxScore);
    
    }
    void gradeAvg(struct Class *head,int Classnum,int stunum)
    {
        struct Class *pclass=head;
        struct student *pstu;
        int gradeSum=0;
        int numOfStu;
        float gradeAvg;
       // float maxAvg;
        int i;
        int j;
        for(i=0;i<Classnum;i++){
            pstu=pclass->messageHead;
            for(j=0;j<stunum;j++){
                numOfStu++;
                gradeSum+=pstu->sum; 
                pstu=pstu->next;
            }
            pclass=pclass->next;
    
        }
        gradeAvg=(float)gradeSum/numOfStu;
        printf("---------------年级平均分--------------\n");
        printf("年级平均分是%f\n",gradeAvg);
    }
    int main()
    {
        int a;
        int b;
        struct Class *head;
        printf("请输入班级数量:\n");
        scanf("%d",&a);
        printf("请输入班级人数量:\n");
        scanf("%d",&b);
        head=ClassMessage(head,a,b); 
        printMessage(head,b,a);
        findMathMaxScore(head,a,b);
        findChineseMaxScore(head,a,b);
        findEnglishMaxScore(head,a,b);
        gradeAvg(head,a,b);
        return 0;
    }
    
    展开全文
  • printf(" 学生信息管理系统\n"); printf("**************************************************************\n\n"); print_list(psthead); printf("*************************************************************...

    运行主菜单如图所示

    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
    
    展开全文
  • 双向循环链表实践---学生管理系统

    千次阅读 2018-01-27 18:36:23
    写在前面 在看Linux源码时,经常会涉及到驱动和设备的匹配,如果想弄清楚匹配过程,就要理解双向循环链表。...首先定义一个结构体,存放学生信息 struct student { int number; char id[20];

    写在前面

    在看Linux源码时,经常会涉及到驱动和设备的匹配,如果想弄清楚匹配过程,就要理解双向循环链表。
    这篇文章是理解了Linux的list.h文件后自己的实现应用。

    理论知识

    这里写图片描述

    实现步骤

    链表的常用的节点操作如下:
    增加、删除、查找

    首先定义一个结构体,存放学生的信息

    struct student {
        int number;
        char id[20];   //学号
        char name[20]; //姓名
        float score;   //成绩
        struct student *next;
        struct student *prev;
    };
    创建头节点
    1. 创建头指针
    2. 初始化头指针
      1. 分配内存
      2. 自己指向自己
    struct student *head = NULL;
    
    /*create head node*/
    void init(void)  
    {
        printf("%s\n", __func__);
        head = (struct student *)malloc(sizeof(struct student));
        head->next = head;   
        head->prev = head;
    }
    增加节点
    void add_student(void)
    {
        /*增加一个学生的信息*/
        char new_id[20] = {0};
        char new_name[20] = {0};
        float new_score = 0.00;
        memset(new_id, 0, sizeof(new_id));
        memset(new_name, 0, sizeof(new_name));
    
        printf("%s\n", __func__);
    
        printf("enter the id:\n");
        scanf("%s", new_id);
    
        /*id是唯一的依据,所以要进行去重操作*/
        if(have_same_id(new_id)){
            printf("hava same id\n");
            goto have_same_id;
        }
    
        printf("enter the name:\n");
        scanf("%s", new_name);
        printf("enter the score:\n");
        scanf("%f", &new_score);
    
        /*增加新节点核心操作*/
        struct student * new_node = (struct student *)malloc(sizeof(struct student));
        struct student * last_node = head->prev;
        last_node->next = new_node;
        new_node->prev = last_node;
        head->prev = new_node;
        new_node->next = head;
    
        count++;
        /*节点信息填充*/
        new_node->number = count;
        memset(new_node->id, 0, sizeof(new_node->id));
        memset(new_node->name, 0, sizeof(new_node->name));
        strcpy(new_node->id, new_id);
        strcpy(new_node->name, new_name);
        new_node->score = new_score;
    
        printf("add student ok!\n");
    
        list_all_student();
    
    have_same_id:
        return ;
    }
    #define HAVE_SAME_ID    1
    #define NO_SAME_ID      0
    
    int have_same_id(char *id)
    {
        struct student *pos = NULL;
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                return HAVE_SAME_ID;
            }
        }
        return NO_SAME_ID;
    }
    删除节点
    void delete_student()
    {
        struct student * pos = NULL;
        char id[20];
        printf("%s\n", __func__);
    
        memset(id, 0, sizeof(id));
        /*以ID为唯一凭证*/
        printf("enter the id that you want delete:\n");
        scanf("%s", id);
    
        //删除节点核心实现
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                printf("delete\t%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
                pos->prev->next = pos->next;
                pos->next->prev = pos->prev;
                free(pos);
                delete_student_fixed_count(); //删除节点后,修复节点中number标记
                return;
            }
        }
    
        printf("no the same id, pleace check it again\n");
    
    }
    void delete_student_fixed_count(void)
    {
        struct student *pos = NULL; 
        int i = 0;
        count--;
        for(pos = head->next, i = 1; pos != head; pos = pos->next, i++)
        {
            pos->number = i;
        }
        i--;
        if(i != count){
            printf("i = %d\t, count = %d\n", i, count);
            printf("count error\n");
        }
        list_all_student();
    
    }
    查找节点

    查找结点比较简单,根据一个值遍历所有节点即可
    示例代码中,以学生ID为唯一参考

    void search_student_score(void)
    {
        struct student * pos = NULL;
        char id[20];
        printf("%s\n", __func__);
    
        memset(id, 0, sizeof(id));
    
        printf("enter the id that want to search:\n");
        scanf("%s", id);
    
        //核心代码
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                printf("find the id:\n");
                printf("\tid\t\t\tname\t\t\tsorce\n");
                printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
                return;
            }
        }
        printf("sorry, can not find the id info\n");
    
    }

    释放节点

    由于内存空间是使用malloc进行分配的,所有要用free进行手动释放,释放某一个节点比较简单,释放所有节点相对复杂点,其实就是遍历所有节点,并一一删除。

    释放一个节点
    1. 以ID为标记,找到要释放的节点
    2. 注意修改节点的next和prev节点
    3. 释放该节点的内存
    void delete_student()
    {
        struct student * pos = NULL;
        char id[20];
        printf("%s\n", __func__);
    
        memset(id, 0, sizeof(id));
        printf("enter the id that you want delete:\n");
        scanf("%s", id);
    
        //核心实现
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                printf("delete\t%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
                pos->prev->next = pos->next;
                pos->next->prev = pos->prev;
                free(pos);
                delete_student_fixed_count();
                return;
            }
        }
    
        printf("no the same id, pleace check it again\n");
    
    }
    删除所有节点

    结束程序时,要删除所有分配过的内存,防止内存泄漏
    该操作就是遍历所有节点并释放内存

    void free_all_memory()
    {
        struct student * pos = head->next;
        printf("%s\n", __func__);
        for(; pos != head; )
        {
            head->next = pos->next;
            pos->next->prev = head;
            printf("\tdelete node->number = %d\n", pos->number);   //显示所有要删除的节点,防止有内存泄露
            free(pos);
            pos = head->next;
        }
        printf("\tdelete head node\n");
        free(head);
    }

    完整代码

    此示例代码,已经实验过,无内存泄漏,所有功能实现。

    /*************************
        双向循环链表练习
          学生管理系统
           2018.01.27
            cxiaolei
    *************************/
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define HAVE_SAME_ID    1
    #define NO_SAME_ID      0
    
    struct student {
        int number;
        char id[20];   //学号
        char name[20]; //姓名
        float score;//成绩
        struct student *next;
        struct student *prev;
    };
    
    int count = 0;
    
    struct student *head = NULL;
    
    /*create head node*/
    void init(void)  
    {
        printf("%s\n", __func__);
        head = (struct student *)malloc(sizeof(struct student));
        head->next = head;   
        head->prev = head;
    }
    
    void list_all_student(void)
    {
        struct student *pos = NULL;
        printf("%s\n", __func__);
        printf("\n\n\n\tid\t\t\tname\t\t\tsorce\n");
        for(pos = head->next; pos != head; pos = pos->next)
        {
            printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
        }
        printf("\n\n\n%s : end\n", __func__);
    }
    
    int have_same_id(char *id)
    {
        struct student *pos = NULL;
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                return HAVE_SAME_ID;
            }
        }
        return NO_SAME_ID;
    }
    
    void delete_student_fixed_count(void)
    {
        struct student *pos = NULL; 
        int i = 0;
        count--;
        for(pos = head->next, i = 1; pos != head; pos = pos->next, i++)
        {
            pos->number = i;
        }
        i--;
        if(i != count){
            printf("i = %d\t, count = %d\n", i, count);
            printf("count error\n");
        }
        list_all_student();
    
    }
    
    void add_student(void)
    {
        char new_id[20] = {0};
        char new_name[20] = {0};
        float new_score = 0.00;
        memset(new_id, 0, sizeof(new_id));
        memset(new_name, 0, sizeof(new_name));
    
        printf("%s\n", __func__);
    
        printf("enter the id:\n");
        scanf("%s", new_id);
    
        if(have_same_id(new_id)){
            printf("hava same id\n");
            goto have_same_id;
        }
    
        printf("enter the name:\n");
        scanf("%s", new_name);
        printf("enter the score:\n");
        scanf("%f", &new_score);
    
        struct student * new_node = (struct student *)malloc(sizeof(struct student));
        struct student * last_node = head->prev;
        last_node->next = new_node;
        new_node->prev = last_node;
        head->prev = new_node;
        new_node->next = head;
    
        count++;
    
        new_node->number = count;
        memset(new_node->id, 0, sizeof(new_node->id));
        memset(new_node->name, 0, sizeof(new_node->name));
        strcpy(new_node->id, new_id);
        strcpy(new_node->name, new_name);
        new_node->score = new_score;
    
        printf("add student ok!\n");
    
        list_all_student();
    
    have_same_id:
        return ;
    }
    
    void delete_student()
    {
        struct student * pos = NULL;
        char id[20];
        printf("%s\n", __func__);
    
        memset(id, 0, sizeof(id));
        printf("enter the id that you want delete:\n");
        scanf("%s", id);
    
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                printf("delete\t%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
                pos->prev->next = pos->next;
                pos->next->prev = pos->prev;
                free(pos);
                delete_student_fixed_count();
                return;
            }
        }
    
        printf("no the same id, pleace check it again\n");
    
    }
    
    void search_student_score(void)
    {
        struct student * pos = NULL;
        char id[20];
        printf("%s\n", __func__);
    
        memset(id, 0, sizeof(id));
    
        printf("enter the id that want to search:\n");
        scanf("%s", id);
    
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                printf("find the id:\n");
                printf("\tid\t\t\tname\t\t\tsorce\n");
                printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
                return;
            }
        }
        printf("sorry, can not find the id info\n");
    
    }
    
    void modify_student_score(void)
    {
        struct student * pos = NULL;
        char id[20];
        float score = 0.00;
        printf("%s\n", __func__);
    
        memset(id, 0, sizeof(id));
    
        printf("enter the id that want to modify:\n");
        scanf("%s", id);
        printf("enter the score that want to modify:\n");
        scanf("%f", &score);
    
        for(pos = head->next; pos != head; pos = pos->next)
        {
            if(strcmp(pos->id, id) == 0){
                printf("find the id and modify the score:\n");
                pos->score = score;
                printf("\tid\t\t\tname\t\t\tsorce\n");
                printf("%d\t%s\t\t\t%s\t\t\t%f\n", pos->number, pos->id, pos->name, pos->score);
                return;
            }
        }
        printf("sorry, can not find the id info\n");
    }
    
    void free_all_memory()
    {
        struct student * pos = head->next;
        struct student * pos_next = NULL;
        printf("%s\n", __func__);
        for(; pos != head; )
        {
            //pos_next = pos->next;
            head->next = pos->next;
            pos->next->prev = head;
            printf("\tdelete node->number = %d\n", pos->number);
            free(pos);
            pos = head->next;
        }
        printf("\tdelete head node\n");
        free(head);
    }
    
    int main(void)
    {
        int user_select = 0;
    
        init();
    
        printf("简单的学生管理系统");
        while(1){
            printf("function select\n");
            printf("\t1. add a student info\n\t2. delete a student info\n\t3. search student score\n\t4. modify student score\n\t5. list all student\n\t0. quit the application\n");
            scanf("%d", &user_select);
            switch(user_select){
                case 0:{
                    free_all_memory();
                    printf("the application will quit\n");
                    return 0;
                }           
                case 1:{
                    add_student();
                    break;
                }
                case 2:{
                    delete_student();
                    break;
                }       
                case 3:{
                    search_student_score();
                    break;
                }
                case 4:{
                    modify_student_score();
                    break;
                }
                case 5:{
                    list_all_student();
                    break;
                }
                default:{
                    printf("enter error\n");
                    free_all_memory();
                    break;
                }
            }
        }
        return 0;
    }
    
    展开全文
  • 改源代码用链表实现了学生信息的增删改查,读写入(出)文件,同时实现了学生信息的排序,链表的清空,插入。双向链表的插入排序,能够帮助学习链表。
  • 系统应完成一下几方面的功能: (1)输入信息——enter(); (2)显示信息———display( ); (3)查找以姓名作为关键字 ———search( ); (4)删除信息...
  • 利用C语言双向链表实现的学生信息管理系统Demo
  • 下面使用内核链表完成基本的增删改查,实现简易的学生信息管理系统,拥有保存信息到txt文本的功能,和从txt中读取信息的功能。(内核链表的头文件可以百度直接下载) #include"kernel_list.h" //内核链表的头,只...
  • 回头学学C++与数据结构,巩固下基础。当然看完这篇博客是有作业的~ 话不多说,进入主题。关于链表的学习,我想大家先对此的有个概念。然后再来看这篇博文,本文...本文会介绍这三种方法,其中第三种方法实现了一个学生
  • 1、主程序模块主要功能:程序的入口主要文件:main.c2、菜单模块主要功能:完成菜单的显示和调用相应功能函数主要文件:menu.h menu.c3、学生模块主要功能:完成学生结构定义,添加学生,删除学生,修改学生,查找...
  • 基于双向链表实现的教务管理系统 增删改查
  • //修改学生信息 bool alter_grades(listnode head,listnode newOne) { int id_num,grade,subject,judgeStu,teaSubject = 0; printf("please input the student's id_num :"); scanf("%d",&id_num); while...
  • 双向循环链表-仿学生管理系统【详尽注释】 具备创建、添加、删除、查找、修改、排序、及输出!
  • 学生管理系统 功能选择界面如下: ***************************************************** *** 输入学生信息请按1 *** *** 删除学生信息请按2 *** *** 查找学生信息请按3 *** *** 修改学...
  • 基于双向循环链表实现的学生管理系统,包括初始化,插入,删除,查抄,保存,自动按照姓名排序功能,退出并保存功能。
  • 题目 ...我是定义两个结构体,相当于两个链表学生信息和班级信息,打算在班级信息结构体中定义一个结构体指针指向学生信息。 参考代码 #include <stdio.h> #include <stdlib.h> #inc
  • STMS学生信息管理系统; 采用C语言、由双链表实现,有学生、老师、管理员三种角色登陆,每种角色权限功能不一样。
  • typedef struct Dnode { //定义双向链表 ElemType data;//定义数据域类型 struct Dnode *prior;//定义前驱指针 struct Dnode *next;//定义后驱指针 } Dnode,*DLinkList; Status InitList(DLinkList &L) { //初始...
  • 链表做的简单c语言学生管理系统

    千次阅读 多人点赞 2017-07-14 15:46:31
    链表做的简单c语言学生管理系统 里面有用到简单的文件操作 #include #include struct STU {  int num;  char name[5];  int score;  struct STU *next; }; struct STU *Creatlink_t();//创建链表 void ...
  • 摘 要:本课程设计设计一个实用的小型通讯录管理系统,用文件来存储学生的姓名、电话、QQ号码、邮编、地址等信息,完成对信息的添加、删除、查询、显示所有信息,退出及用双向链表来处理修改等操作。 在本课程设计中,...
  • 链表嵌套实现学生管理系统

    千次阅读 2020-08-11 11:19:12
    做一个学生成绩管理系统 学生成绩有语文 数学 英语 功能: 录入成绩 找最三科总分的最高分 最低分 算出平均分 首先这是一个双链表的题目(也就是两个结构体)首先我们要定义两个结构体,class和student struct Class...
  • 通讯录管理系统是一个比较实用的小型管理系统。随着生活节奏的加快,人们追求丰富便捷的电子产品体验,因此也提高对便捷方式的喜爱。当今社会下人们的交际范围越来越广泛,通讯录系统的出现,方便了人们存储通讯录,...
  • 链表实现通讯录管理系统-C++

    千次阅读 2018-10-31 09:34:27
    用数据结构里面线性结构的链表实现 文件操作未写 有登录操作,复制源码需要更改登录模块的密码文件存放位置 使用VS2017编译器需要保留开头:#define _CRT_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS ...
  • 课程名称:C语言控制台版信息管理系统 应用知识:C语言,链表 课程目的: 1、练习C语言知识综合运用 2、巩固复习链表应用 3、巩固C语言基础知识 4、掌握控制台游戏基本方法 代码数量:1000左右 课程特点: 1、知识点...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,203
精华内容 1,281
关键字:

双向链表学生信息管理系统