C语言实现学生信息管理系统

怼烎@ 2023-09-26 16:16 133阅读 0赞

***c语言课程作业***

### 如果程序有错误，欢迎指出。 ###

***相信很多这个学期学了C语言的小伙伴都有这个作业要求吧，以下代码可供借鉴***

### 功能要求： ###

1.  使用链表实现
2.  具有保存与读取数据功能(以文件形式保存)
3.  能进行增、删、改、查、的操作

***此程序在vscode环境下编译运行无异常，如果用vs2022的话，应该会报警告：因为不是用scanf\_s，所以需要在vs2022上编译运行的话，需要在.c文件开头添加一行代码***

#define _CRT_SECURE_NO_WARNINGS

### 以下为结构体数据定义部分 ###

***学生课程成绩结构体：***  
对于课程可自行修改变量名与添加变量  
不过要注意，修改了科目变量的话，整个程序也要随之更新，特别是文件数据加载函数  
与数据保存函数

/*学生成绩结构体*/
    typedef struct scores
    {
        
        float math;         /*数学*/
        float Chinese;      /*语文*/
        float English;      /*英语*/
        float Average_score; /*平均分*/
        float Total_score;  /*总分*/
    }SCORES;

存放学生个人信息的数组大小等：

/*姓名*/
    #define NAME_MAX 14
            /*年龄*/
    #define AGE_MAX 4
            /*班级*/
    #define GENDER_MAX 30
            /*性别*/
    #define CLASS_MAX 4
            /*课程数量*/
    #define Number_of_lessons 3
            /*最大分数，成绩最高不能超过 MAX_score */
    #define MAX_score 100

学生个人信息结构体：

/*学生数据相关结构体*/
    typedef struct student
    {
        
        char Class[CLASS_MAX];      /*性别*/
        char Age[AGE_MAX];          /*年龄*/ 
        char Name[NAME_MAX];        /*姓名*/
        char Gender[GENDER_MAX];    /*班级*/
        SCORES scores;              /*指向学生成绩结构体的指针*/
    }STUDENT;

链表操作结构体：

/*链表相关操作结构体*/
    typedef struct NODE
    {
        
        /*指向学生信息的结构体*/
        STUDENT data;  
        /*此指针指向下一个结点*/
        struct NODE *Next;
    }NODE;

### .c文件部分 ###

***整个程序分为.c文件与.h文件实现，分为两个部分进行写程序更好操作
    .c 程序部分：Student.c***

#include "Student.h"
    
    int main(void)
    {
        
        NODE head;  /*头结点*/
        int number;
        initialize(&head);  /*初始化函数*/
        do
        {
           
            /*菜单界面输出函数*/
            Interface_output(); 
            printf("请选择需要使用的功能：");
            scanf("%d",&number);
            fflush(stdin); /*清空缓冲区库函数、stdin为输入、作用为清空输入缓冲区*/
            switch(number)
            {
          
                        /*链表的建立与结点的添加 与  学生总分与平均分计算函数*/
                case 1 : {
        create_list(&head); Calculate_Total_Score(&head); break;}
                        /*遍历链表并输出结点内容*/
                case 2 : {
        traverse_list(&head);break;}
                        /*修改结点数据内容*/
                case 3 : {
        Modify_the_data(&head);break;}
                        /*根据学生成绩排序*/
                case 4 : {
        Student_sort(&head);break;}
                        /*根据输入的标识进行删除结点*/
                case 5 : {
        Delete_data(&head);break;}
                        /*查找数据*/
                case 6 : {
        Find_data(&head);break;}
                        /*清空数据 0 表示会清空文件内的内容*/
                case 9 : {
        Empty_data(&head,0);break;}
                        /*用户提示函数*/
                case 7 : {
         prompt(); break;}
    
                default : break;
            }
         
            system("pause");
            system("cls");
        } while (number != 0);
        
        /*数据保存到文件内*/
        Data_saving(&head);
        /*清空数据 1 表示不会清空文件内的内容*/
        Empty_data(&head,1);
    
        free(head.Next);
        return 0;
    }

### .h文件部分 ###

***由于.h文件程序有点多，所以我就先挑几个重要的函数放出来，之后的整个.h文件会放在文章末尾，大家自行查看。***

### 头文件部分 ###

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>

### 以下为四个基本函数：增、删、改、查。 ###

### 创建链表函数 ###

***此函数将创建结点与新增结点功能融合再一起实现***

/*创建函数*/
    void create_list(NODE *phead)
    {
        
        NODE *temp;
        NODE *pnode=phead;
        int number=0;   /*判断用户是否继续输入*/
        system("cls");
        /*判断链表是否已有数据，有数据的话将pnode指针移动到链表尾部结点，方便进行结点的添加*/
        while(pnode->Next != NULL)
            {
         pnode=pnode->Next; }
        do
        {
        
            temp=(NODE *)malloc(sizeof(NODE));
            if(temp == NULL)
                {
        printf("申请内存空间失败！\n");return;}
    
            printf("请输入学生姓名：");
            scanf("%s",temp->data.Name);
            printf("\n请输入学生年龄：");
            scanf("%s",(temp->data.Age));
            printf("\n请输入学生性别：");
            scanf("%s",temp->data.Class);
            printf("\n请输入学生班级：");
            scanf("%s",temp->data.Gender);
            
            printf("\n请输入学生数学成绩：");
            scanf("%f",&temp->data.scores.math);
            printf("\n请输入学生语文成绩：");
            scanf("%f",&temp->data.scores.Chinese);
            printf("\n请输入学生英语成绩：");
            scanf("%f",&temp->data.scores.English);  
            /*指针后移*/
            pnode->Next=temp;
            pnode=temp;
    
            printf("\n是否继续添加(1/0)：");
            scanf("%d",&number);     
            fflush(stdin);  /*清空缓冲区函数、stdin为输入、作用为清空输入缓冲区*/
            system("pause");
            system("cls");
        } while(number != 0 && number == 1);
        pnode->Next=NULL;
        printf("已退出添加信息！\n\n");
    }

### 删除结点函数 ###

***此函数根据学生的姓名查找结点并删除结点***

/*删除数据函数*/
    void Delete_data(NODE *phead)
    {
        
        int i=0;
        int len_lsit;
        char str[4];        
        NODE *pnode=phead;  /*指针指向头结点*/
        NODE *p_temp=NULL;  /*用于指向需要删除的那个结点*/
        char temp_Name[NAME_MAX];
        system("cls");
    
        if(phead->Next == NULL)
            {
        printf("\n数据为空！无可修改内容！\n"); return;}
    
        printf("请输入需要修改信息的学生姓名：");
        scanf("%s",temp_Name);
        
        /*获取链表长度*/
        len_lsit=Lsit_len(phead);   /* Lsit_len() 是用于计算链表长度的函数*/
        
        while(i < len_lsit)
        {
           /*判断链表内是否有用户输入的字符串*/
            if( strcmp(temp_Name,pnode->Next->data.Name) == 0)
                {
         break; }  
            pnode=pnode->Next;
            i++;
        }
        /*如果上个循环没有被break退出的话，会一直迭代到链表尾部,然后进入if*/
        if(pnode->Next == NULL)
            {
         printf("\n未查找到此学生！请确认是否输入正确！\n");return; }
        else
        {
           
            printf("\n");
            printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
            /*输出需要删除学生的信息*/
            PUT_list_data(pnode->Next);  /*PUT_list_data函数的作用是输出传入结点的信息*/
            printf("\n是否确实删除？(yes/no)：");
            scanf("%s",str);
            if(strcmp(str,"yes") == 0)
            {
           /*删除结点*/
                p_temp=pnode->Next->Next;
                free(pnode->Next);
                pnode->Next=p_temp;
                printf("\n删除成功！\n");
            }
            else
                {
         printf("\n已中止删除！\n"); }
        }
        return;
    }

### 修改结点函数 ###

***此函数根据学生姓名进行查找并修改其结点内容***

/*修改结点内容函数*/
    void Modify_the_data(NODE *phead)
    {
        
        int choose=0;
        NODE *pnode=phead->Next;
        char temp_Name[NAME_MAX];
    
        system("cls");
    
        if(pnode == NULL)
            {
        printf("数据为空！无可修改内容！\n"); return;}
    
        printf("请输入需要修改信息的学生姓名：");
        scanf("%s",temp_Name);
    
        while(pnode != NULL)
        {
           /*判断链表内是否有用户输入的字符串*/
            if( strcmp(temp_Name,pnode->data.Name) == 0)
                {
         break; }  
            pnode=pnode->Next;
        }
        /*如果上个循环没有被break退出的话，会一直迭代到链表尾部,然后进入if*/
        if(pnode == NULL)
        	{
         printf("未查找到此学生！请确认是否输入正确！\n"); return; }
        do
        {
        
            system("cls");
            printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
            /*数据输出函数*/
            PUT_list_data(pnode);   /*PUT_list_data函数的作用是输出传入结点的信息*/
    
            printf("\n请输入需要修改的数据序号(0.退出)：");
            scanf("%d",&choose);
    
            switch(choose)
            {
        
                case 0 : printf("\n退出修改成功！\n");break;
                case 1 : printf("\n请输入新的姓名：");scanf("%s",pnode->data.Name);break;
                case 2 : printf("\n请输入新的年龄：");scanf("%s",pnode->data.Age);break;
                case 3 : printf("\n请输入新的性别：");scanf("%s",pnode->data.Class);break;
                case 4 : printf("\n请输入新的班级：");scanf("%s",pnode->data.Gender);break;
    
                case 5 : printf("\n请输入新的数学成绩：");scanf("%f",&pnode->data.scores.math);break;
                case 6 : printf("\n请输入新的语文成绩：");scanf("%f",&pnode->data.scores.Chinese);break;
                case 7 : printf("\n请输入新的英语成绩：");scanf("%f",&pnode->data.scores.English);break;
                default : printf("输入错误！请确认是否正确输入！\n");break;
            }
            if(choose != 0 ) {
        printf("\n修改成功！\n");}
            system("pause");
    
        } while (choose != 0);
        
        /*更新总分与平均分并赋值，以防以上操作修改了本结点学生的成绩*/
        pnode->data.scores.Total_score= (pnode->data.scores.Chinese + pnode->data.scores.English + pnode->data.scores.math);
        pnode->data.scores.Average_score= (pnode->data.scores.Chinese + pnode->data.scores.English + pnode->data.scores.math) / Number_of_lessons;
    }

### 查找信息函数 ###

***根据用户选择的功能序号进行查找***

/*查找函数*/
    void Find_data(NODE *phead)
    {
        
        int choose;
        
        if(phead->Next == NULL)
            {
        printf("无数据查找！\n"); return;}
    
        do
        {
        
            system("cls");
            printf("\n%-10s %-10s %-10s %-10s %s\n","1.按班级查找输出","2.按姓名查找输出","3.将总分高于某个分数线的人输出","4.将总分低于某个分数线的人输出","0.退出");
            printf("\n请输入需要使用的功能序号：");
            scanf("%d",&choose);
            fflush(stdin);  /*清空缓冲区函数、stdin为输入、作用为清空输入缓冲区*/
    
            /*判断，符合条件的进入if 调用查找函数*/
            if(choose >= 1 && choose < 5)
            {
        
                traverse_Find(phead,choose);    /*遍历并输出符合条件的数据*/
            }
            if(choose < 0 || choose > 5)
                {
         printf("无此功能！请正确选择！\n"); }
            system("pause");
        } while (choose);
    }
    
    /*功能实现函数：遍历查找并输出*/
    void traverse_Find(NODE *phead,unsigned int key)
    {
        
        float Passing_line;      /*用于比较是否及格*/
        char *pstr=NULL;    /*用于承载用户输入的查找关键字*/
        NODE *p_node=NULL;  /*用于链表的指针的后移*/
    
        if(phead == NULL)
            {
        printf("traverse_Find函数 传入指针为空！\n");return;}
        p_node=phead->Next; /*指向链表*/
    
        switch(key)
        {
                       /*根据用户需要为pstr动态申请足够的空间*/
            case 1 :{
         pstr=(char *)malloc(sizeof(char) * GENDER_MAX);break; }   /*班级*/
            case 2 :{
         pstr=(char *)malloc(sizeof(char) * NAME_MAX);break; }     /*姓名*/
        }
        if(key == 1 || key == 2)
        {
        
            printf("\n请输入需要查找的关键词：");
            scanf("%s",pstr);
        }
        else
        {
        
            printf("\n请输入分数线的数值：");
            scanf("%f",&Passing_line);
        }
            
        /*根据用户选择的功能序号而进行查找 1 是通过班级查找 2 是通过姓名查找*/
        switch (key)
        {
        
            case 1 : {
        
                    printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                    /*迭代判断是否符合需要查找的关键字*/
                    while(p_node != NULL)
                    {
           /*判断链表中是否有与用户输入关键字相同的信息*/
                        if( (strcmp(p_node->data.Gender,pstr)) == 0)
                            {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                        p_node=p_node->Next;
                    }break;
            }
    
            case 2 : {
        
                    printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                    /*迭代判断是否符合需要查找的关键字*/
                    while(p_node != NULL)
                    {
           /*迭代判断是否符合需要查找的关键字*/
                        if( (strcmp(p_node->data.Name,pstr)) == 0)
                            {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                        p_node=p_node->Next;
                    }break; 
                }
            case 3 :{
        
                printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                while(p_node != NULL)
                {
           /*迭代判断*/
                    if( p_node->data.scores.Total_score > Passing_line)
                        {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                    p_node=p_node->Next;
                }
                printf("\n以上为高于 %.1f 分数的人\n",Passing_line);break; 
            }
            case 4 :{
        
                printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                while(p_node != NULL)
                {
           /*迭代判断*/
                    if( p_node->data.scores.Total_score < Passing_line)
                        {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                    p_node=p_node->Next;
                }
                printf("\n以上为低于 %.1f 分数的人\n",Passing_line);break; 
            }
        }
        free(pstr); /*释放上面动态申请的空间*/
        pstr=NULL;
    }

### 以下部分是整个Student.h文件部分 ###

***长篇警告⚠！！！***  
***长篇警告⚠！！！***  
***长篇警告⚠！！！***

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
            /*姓名*/
    #define NAME_MAX 14
            /*年龄*/
    #define AGE_MAX 4
            /*班级*/
    #define GENDER_MAX 30
            /*性别*/
    #define CLASS_MAX 4
            /*课程数量*/
    #define Number_of_lessons 3
            /*最大分数，成绩最高不能超过 MAX_score */
    #define MAX_score 100
    
    /*学生成绩结构体*/
    typedef struct scores
    {
        
        float math;         /*数学*/
        float Chinese;      /*语文*/
        float English;      /*英语*/
        float Average_score; /*平均分*/
        float Total_score;  /*总分*/
    }SCORES;
    
    /*学生数据相关结构体*/
    typedef struct student
    {
        
        char Class[CLASS_MAX];      /*性别*/
        char Age[AGE_MAX];          /*年龄*/ 
        char Name[NAME_MAX];        /*姓名*/
        char Gender[GENDER_MAX];    /*班级*/
        SCORES scores;              /*指向学生成绩结构体的指针*/
    }STUDENT;
    
    /*链表相关操作结构体*/
    typedef struct NODE
    {
        
        /*指向学生信息的结构体*/
        STUDENT data;  
        /*此指针指向下一个结点*/
        struct NODE *Next;
    }NODE;
    
    /*提醒用户函数*/
    void prompt(void);
    /*计算链表长度 返回值为 int */
    int Lsit_len(NODE *phead);
    /*查找函数*/
    void Find_data(NODE *phead);
    /*删除数据函数*/
    void Delete_data(NODE *phead);
    /*创建函数*/
    void create_list(NODE *phead);
    /*学生成绩排序*/
    void Student_sort(NODE *phead);
    /*数据初始化函数*/
    void initialize(NODE *phead);
    /*界面输出函数*/
    void Interface_output(void);
    /*数据保存到文件内的函数*/
    void Data_saving(NODE *phead);
    /*文件数据加载函数*/
    void File_loading(NODE *phead);
    /*数据输出函数*/
    void PUT_list_data(const NODE *p_node);
    /*遍历输出函数*/
    void traverse_list(const NODE *phead);
    /*根据形参进行排序*/
    void Rank_sqrt(NODE *phead,int key);
    /*计算学生成绩总分与平均分*/
    void Calculate_Total_Score(NODE *phead);
    /*清空数据函数*/
    void Empty_data(NODE *phead,unsigned int key);
    /*遍历查找并输出*/
    void traverse_Find(NODE *phead,unsigned int key);
    
    /*数据输出函数*/
    void PUT_list_data(const NODE *p_node)
    {
        
        /*输出学生学信息*/
        /*姓名等个人信息*/
        printf("%-11s",p_node->data.Name);
        printf("%-8s",p_node->data.Age);
        printf("%-6s",p_node->data.Class);
        printf("%-25s",p_node->data.Gender);
        /*三科成绩*/
        printf("%-10.1f",p_node->data.scores.math);
        printf("%-12.1f",p_node->data.scores.Chinese);
        printf("%-10.1f",p_node->data.scores.English);
        /*总分与平均分*/
        printf("%-10.1f",p_node->data.scores.Average_score);
        printf("%.02f\n",p_node->data.scores.Total_score);
    }
    
    /*遍历查找并输出*/
    void traverse_Find(NODE *phead,unsigned int key)
    {
        
        float Passing_line;      /*用于比较是否及格*/
        char *pstr=NULL;    /*用于承载用户输入的查找关键字*/
        NODE *p_node=NULL;  /*用于链表的指针的后移*/
    
        if(phead == NULL)
            {
        printf("traverse_Find函数 传入指针为空！\n");return;}
        p_node=phead->Next; /*指向链表*/
    
        switch(key)
        {
                       /*根据用户需要为pstr动态申请足够的空间*/
            case 1 :{
         pstr=(char *)malloc(sizeof(char) * GENDER_MAX);break; }   /*班级*/
            case 2 :{
         pstr=(char *)malloc(sizeof(char) * NAME_MAX);break; }     /*姓名*/
        }
        if(key == 1 || key == 2)
        {
        
            printf("\n请输入需要查找的关键词：");
            scanf("%s",pstr);
        }
        else
        {
        
            printf("\n请输入分数线的数值：");
            scanf("%f",&Passing_line);
        }
            
        /*根据用户选择的功能序号而进行查找 1 是通过班级查找 2 是通过姓名查找*/
        switch (key)
        {
        
            case 1 : {
        
                    printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                    /*迭代判断是否符合需要查找的关键字*/
                    while(p_node != NULL)
                    {
           /*判断链表中是否有与用户输入关键字相同的信息*/
                        if( (strcmp(p_node->data.Gender,pstr)) == 0)
                            {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                        p_node=p_node->Next;
                    }break;
            }
    
            case 2 : {
        
                    printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                    /*迭代判断是否符合需要查找的关键字*/
                    while(p_node != NULL)
                    {
           /*迭代判断是否符合需要查找的关键字*/
                        if( (strcmp(p_node->data.Name,pstr)) == 0)
                            {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                        p_node=p_node->Next;
                    }break; 
                }
            case 3 :{
        
                printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                while(p_node != NULL)
                {
           /*迭代判断*/
                    if( p_node->data.scores.Total_score > Passing_line)
                        {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                    p_node=p_node->Next;
                }
                printf("\n以上为高于 %.1f 分数的人\n",Passing_line);break; 
            }
            case 4 :{
        
                printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
                while(p_node != NULL)
                {
           /*迭代判断*/
                    if( p_node->data.scores.Total_score < Passing_line)
                        {
         PUT_list_data(p_node); }  /*PUT_list_data 为数据输出函数，输出符合关键词的数据*/
                    p_node=p_node->Next;
                }
                printf("\n以上为低于 %.1f 分数的人\n",Passing_line);break; 
            }
        }
        free(pstr); /*释放上面动态申请的空间*/
        pstr=NULL;
    }
    
    /*查找函数*/
    void Find_data(NODE *phead)
    {
        
        int choose;
        
        if(phead->Next == NULL)
            {
        printf("无数据查找！\n"); return;}
    
        do
        {
        
            system("cls");
            printf("\n%-10s %-10s %-10s %-10s %s\n","1.按班级查找输出","2.按姓名查找输出","3.将总分高于某个分数线的人输出","4.将总分低于某个分数线的人输出","0.退出");
            printf("\n请输入需要使用的功能序号：");
            scanf("%d",&choose);
            fflush(stdin);  /*清空缓冲区函数、stdin为输入、作用为清空输入缓冲区*/
    
            /*判断，符合条件的进入if 调用查找函数*/
            if(choose >= 1 && choose < 5)
            {
        
                traverse_Find(phead,choose);    /*遍历并输出符合条件的数据*/
            }
            if(choose < 0 || choose > 5)
                {
         printf("无此功能！请正确选择！\n"); }
            system("pause");
        } while (choose);
    }
    
    /*删除数据函数*/
    void Delete_data(NODE *phead)
    {
        
        int i=0;
        int len_lsit;
        char str[4];        
        NODE *pnode=phead;  /*指针指向头结点*/
        NODE *p_temp=NULL;  /*用于指向需要删除的那个结点*/
        char temp_Name[NAME_MAX];
    
        system("cls");
    
        if(phead->Next == NULL)
            {
        printf("\n数据为空！无可修改内容！\n"); return;}
    
        printf("请输入需要修改信息的学生姓名：");
        scanf("%s",temp_Name);
        
        /*获取链表长度*/
        len_lsit=Lsit_len(phead);   /* Lsit_len() 是用于计算链表长度的函数*/
        
        while(i < len_lsit)
        {
           /*判断链表内是否有用户输入的字符串*/
            if( strcmp(temp_Name,pnode->Next->data.Name) == 0)
                {
         break; }  
            pnode=pnode->Next;
            i++;
        }
        /*如果上个循环没有被break退出的话，会一直迭代到链表尾部,然后进入if*/
        if(pnode->Next == NULL)
            {
         printf("\n未查找到此学生！请确认是否输入正确！\n");return; }
        else
        {
           
            printf("\n");
            printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
            /*输出需要删除学生的信息*/
            PUT_list_data(pnode->Next); 
            printf("\n是否确实删除？(yes/no)：");
            scanf("%s",str);
            if(strcmp(str,"yes") == 0)
            {
           /*删除结点*/
                p_temp=pnode->Next->Next;
                free(pnode->Next);
                pnode->Next=p_temp;
                printf("\n删除成功！\n");
            }
            else
                {
         printf("\n已中止删除！\n"); }
        }
        return;
    }
    
    /*计算学生成绩总分与平均分*/
    void Calculate_Total_Score(NODE *phead)
    {
        
        NODE *pnode=phead->Next;
        if(pnode == NULL)
            {
         printf("计算总分函数传入指针为空指针！未执行功能！\n");return; }
    
        while(pnode != NULL)
        {
        
            /*总分与平均分计算：将本结点学生的语数英成绩加起来，并赋值为本结点的成员：Total_score 存放，方便后续读取*/
            pnode->data.scores.Total_score= (pnode->data.scores.Chinese + pnode->data.scores.English + pnode->data.scores.math);
            /*计算平均分：将每门课的成绩相加然后再除以课程数量*/
            pnode->data.scores.Average_score= (pnode->data.scores.Chinese + pnode->data.scores.English + pnode->data.scores.math) / Number_of_lessons;
            pnode=pnode->Next;
        }
        return;
    }
    
    /*根据形参进行排序*/
    void Rank_sqrt(NODE *phead,int key)
    {
        
        int i,j,len=0;
        float replace_score_1,replace_score_2;  /*两个临时变量，用于存放需要根据什么条件排序的比较数值*/
        NODE *P_node=NULL;
        NODE *P_temp=NULL;
    
        /*链表长度计算函数，返回值为 int */
        len=Lsit_len(phead);    
    
        if(phead->Next == NULL)
            {
         printf("Rank_output函数传入指针为空！\n");return; }
    
        for(i=0; i<len-1; i++)
        {
           
            P_node=phead;   /*为了进行循环而赋初值*/
            for(j=0; j<len-i-1; j++)
            {
           
                switch(key)
                {
        
                    /*根据总分进行排序*/
                    case 1 :{
        
                        replace_score_1=(P_node->Next->data.scores.Total_score);
                        replace_score_2=(P_node->Next->Next->data.scores.Total_score);
                        break; }
                    /*根据平均分进行排序*/
                    case 2 :{
        
                        replace_score_1=(P_node->Next->data.scores.Average_score);
                        replace_score_2=(P_node->Next->Next->data.scores.Average_score);
                        break;}
                }
                
                if( (replace_score_1) < (replace_score_2) )
                {
           
                    /*链表结点交换*/
                    P_temp=P_node->Next;
                    P_node->Next=P_temp->Next;
                    P_temp->Next=P_temp->Next->Next;
                    P_node->Next->Next=P_temp;
                }
                P_node=P_node->Next;
            }
        }
        printf("\n排序成功！\n");
    
        return;
    }
    
    
    /*学生成绩排序*/
    void Student_sort(NODE *phead)
    {
        
        int choose;
    
        system("cls");
    
        if(phead->Next == NULL)
            {
        printf("数据为空！无可排序的内容！\n"); return;}
    
        printf("%-10s %-10s %s\n","1.总分","2.平均分","3.退出");
        printf("请输入需要根据什么信息排序的序号：");
        scanf("%d",&choose);
        fflush(stdin);  /*清空缓冲区函数、stdin为输入缓冲区、作用为清空输入缓冲区*/
        if(choose != 3 && choose > 0)
        {
           /*排序函数*/
            Rank_sqrt(phead,choose);
        }
        else if(choose == 3)
            {
         printf("退出成功！\n"); }
        else
            {
         printf("选择错误！无此功能，已退出排序！\n"); }
        return;
    }
    
    /*获取链表长度*/
    int Lsit_len(NODE *phead)
    {
        
        int len=0;  
        NODE *pnode=phead->Next;    /*链表长度不包括头结点*/
        while(pnode != NULL)
        {
        
            len++;
            pnode=pnode->Next;
        }
        return len;
    }
    
    /*清空数据函数*/
    void Empty_data(NODE *phead,unsigned int key)
    {
        
        FILE *pf;   /*用于清除文件内数据指针*/
        NODE *qnode=phead->Next;
        NODE *pnode=NULL;
        char str[5];
    
        
        system("cls");
        /*根据传入的参数判断是否清空文件内的数据*/
        if(key == 0)    
        {
              
            printf("是否确定清空所有数据(yes/no)：");
            scanf("%s",&str);
            if( strcmp(str,"no") == 0)
                {
        printf("已停止清空数据！\n"); return;}
            pf=fopen("Data_storage.dat","w");   /*清空文件内的所有数据*/
            if(pf == NULL) 
                {
        printf("文件打开时失败！未成功清除文件内数据！\n");}
        }
        /*依次释放所有结点空间*/
        while(qnode != NULL)
        {
           
            pnode=qnode->Next;  
            free(qnode);
            qnode=pnode;
        }
        phead->Next=NULL;
        qnode=NULL;
        pnode=NULL;
        pf=NULL;
        printf("成功清除所有数据！\n\n");
    }
    
    /*修改结点内容函数*/
    void Modify_the_data(NODE *phead)
    {
        
        int choose=0;
        NODE *pnode=phead->Next;
        char temp_Name[NAME_MAX];
    
        system("cls");
    
        if(pnode == NULL)
            {
        printf("数据为空！无可修改内容！\n"); return;}
    
        printf("请输入需要修改信息的学生姓名：");
        scanf("%s",temp_Name);
    
        while(pnode != NULL)
        {
           /*判断链表内是否有用户输入的字符串*/
            if( strcmp(temp_Name,pnode->data.Name) == 0)
                {
         break; }  
            pnode=pnode->Next;
        }
        /*如果上个循环没有被break退出的话，会一直迭代到链表尾部,然后进入if*/
        if(pnode == NULL)
        {
        
            printf("未查找到此学生！请确认是否输入正确！\n");
            return;
        }
        do
        {
        
            system("cls");
            printf("\n%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
            /*数据输出函数*/
            PUT_list_data(pnode);   
    
            printf("\n请输入需要修改的数据序号(0.退出)：");
            scanf("%d",&choose);
    
            switch(choose)
            {
        
                case 0 : printf("\n退出修改成功！\n");break;
                case 1 : printf("\n请输入新的姓名：");scanf("%s",pnode->data.Name);break;
                case 2 : printf("\n请输入新的年龄：");scanf("%s",pnode->data.Age);break;
                case 3 : printf("\n请输入新的性别：");scanf("%s",pnode->data.Class);break;
                case 4 : printf("\n请输入新的班级：");scanf("%s",pnode->data.Gender);break;
    
                case 5 : printf("\n请输入新的数学成绩：");scanf("%f",&pnode->data.scores.math);break;
                case 6 : printf("\n请输入新的语文成绩：");scanf("%f",&pnode->data.scores.Chinese);break;
                case 7 : printf("\n请输入新的英语成绩：");scanf("%f",&pnode->data.scores.English);break;
                default : printf("输入错误！请确认是否正确输入！\n");break;
            }
            if(choose != 0 ) {
        printf("\n修改成功！\n");}
            system("pause");
    
        } while (choose != 0);
        
        /*更新总分与平均分并赋值，以防以上操作修改了本结点学生的成绩*/
        pnode->data.scores.Total_score= (pnode->data.scores.Chinese + pnode->data.scores.English + pnode->data.scores.math);
        pnode->data.scores.Average_score= (pnode->data.scores.Chinese + pnode->data.scores.English + pnode->data.scores.math) / Number_of_lessons;
    }
    
    
    /*遍历输出函数*/
    void traverse_list(const NODE *phead)
    {
        
        int cnt=1;
        NODE *temp=phead->Next;
        
        system("cls");
    
        if(temp == NULL)
            {
        printf("数据为空！无可输出内容！\n"); return;}
    
        printf("  \t%-9s %-6s %-14s %-15s %-10s %-10s %-12s %-10s %s \n\n","姓名","年龄","性别","班级","数学成绩","语文成绩","英语成绩","平均分","总分");
        while(temp != NULL)
        {
        
            printf("%d.\t%-11s",cnt,temp->data.Name);
            printf("%-7s",temp->data.Age);
            printf("%-6s",temp->data.Class);
            printf("%-28s",temp->data.Gender);
            
            printf("%-10.1f",temp->data.scores.math);
            printf("%-12.1f",temp->data.scores.Chinese);
            printf("%-10.1f",temp->data.scores.English);
            printf("%-10.1f",temp->data.scores.Average_score);
            printf("%.02f\n",temp->data.scores.Total_score);
            temp=temp->Next;
            cnt++;
        }
        cnt=0;
        return;
    }
    
    /*创建函数*/
    void create_list(NODE *phead)
    {
        
        NODE *temp;
        NODE *pnode=phead;
        int number=0;   /*判断用户是否继续输入*/
    
        system("cls");
    
        /*判断链表是否已有数据，有数据的话将pnode指针移动到链表尾部结点，方便进行结点的添加*/
        while(pnode->Next != NULL)
            {
         pnode=pnode->Next; }
    
        do
        {
        
            temp=(NODE *)malloc(sizeof(NODE));
            if(temp == NULL)
                {
        printf("申请内存空间失败！\n");return;}
    
            printf("请输入学生姓名：");
            scanf("%s",temp->data.Name);
            printf("\n请输入学生年龄：");
            scanf("%s",(temp->data.Age));
            printf("\n请输入学生性别：");
            scanf("%s",temp->data.Class);
            printf("\n请输入学生班级：");
            scanf("%s",temp->data.Gender);
            
            printf("\n请输入学生数学成绩：");
            scanf("%f",&temp->data.scores.math);
    
            printf("\n请输入学生语文成绩：");
            scanf("%f",&temp->data.scores.Chinese);
    
            printf("\n请输入学生英语成绩：");
            scanf("%f",&temp->data.scores.English);  
    
            /*指针后移*/
            pnode->Next=temp;
            pnode=temp;
    
            printf("\n是否继续添加(1/0)：");
            scanf("%d",&number);     
            fflush(stdin);  /*清空缓冲区函数、stdin为输入、作用为清空输入缓冲区*/
            system("pause");
            system("cls");
        } while(number != 0 && number == 1);
    
        pnode->Next=NULL;
    
        printf("已退出添加信息！\n\n");
    }
    
    /*数据保存函数*/
    void Data_saving(NODE *phead)
    {
        
        NODE *p=phead->Next;
        FILE *pf=fopen("Data_storage.dat","w+");   /*打开数据文件以保存*/
        if(pf == NULL)
            {
        printf("函数：数据保存文件打开失败！功能未执行！\n");return;}
        
        /*将整个链表结点信息逐一保存*/
        while(p != NULL)
        {
           /*往文件内输入数据*/
            fprintf(pf,"%s %s %s %s %f %f %f %f %f\n",p->data.Name,p->data.Age,p->data.Class,p->data.Gender,p->data.scores.math,p->data.scores.Chinese,p->data.scores.English,p->data.scores.Average_score,p->data.scores.Total_score);
            p=p->Next;
        }
    
        /*判断文件的读写是否正常*/
        if(ferror(pf))
        {
        
            printf("文件保存出现问题！\n");
        }
        else if(feof(pf))   /*feof函数会判断文件指针是否读写到了文件尾部而退出*/
        {
        
            printf("文件保存成功！\n");
        }
    
        fclose(pf); /*关闭文件*/
        pf=NULL;
        p=NULL;
        return;
    }
    
    /*文件数据加载函数*/
    void File_loading(NODE *phead)
    {
        
        char ch;
        FILE *pf;
        /*如果文件内有数据将用这两个指针构建一条单链表*/
        NODE *p=(NODE *)malloc(sizeof(NODE));
        NODE *next=(NODE *)malloc(sizeof(NODE));
    
        if(p == NULL || next == NULL)
            {
        printf("文件加载函数中内存申请失败！程序退出未执行！\n");return;}
        
        pf=fopen("Data_storage.dat","a+");
        if(pf == NULL)
            {
        printf("数据加载函数文件打开失败！\n");return;}
    
        /*判断文件内是否有数据*/
        ch=fgetc(pf);
        if(ch == EOF)
        {
        
            printf("数据为空，无需加载！\n");
            system("pause");system("cls");
            return;
        }
        else
            {
         printf("数据开始载入！\n"); }
        phead->Next=p;
        rewind(pf);     /*将文件指针重新指向文件开头*/
        
        fscanf(pf,"%s %s %s %s %f %f %f %f %f",p->data.Name,p->data.Age,p->data.Class,p->data.Gender,&p->data.scores.math,&p->data.scores.Chinese,&p->data.scores.English,&p->data.scores.Average_score,&p->data.scores.Total_score);
    
        while(fscanf(pf,"%s %s %s %s %f %f %f %f %f",next->data.Name,next->data.Age,next->data.Class,next->data.Gender,&next->data.scores.math,&next->data.scores.Chinese,&next->data.scores.English,&p->data.scores.Average_score,&next->data.scores.Total_score) != EOF)
        {
        
            p->Next=next;
            p=next;
    
            next=(NODE *)malloc(sizeof(NODE));
        }
        p->Next=NULL;
        /*将链表的数据进行计算平均分与总分*/
        Calculate_Total_Score(phead);   /*平均分与总分计算函数*/
    
        printf("数据载入成功！\n");
        system("pause");
        system("cls");
    
        fclose(pf); /*关闭文件*/
        pf=NULL;
        return;
    }
    
    /*数据初始化函数*/
    void initialize(NODE *phead)
    {
        
        phead->Next=NULL;
        /*文件数据加载函数*/
        File_loading(phead);      
        return;
    }
    
    /*提醒用户函数*/
    void prompt(void)
    {
        
        system("cls");
        printf("\n注意，运行本程序后会自动生成一个 Data_storage.dat 文件\n");
        printf("\nData_storage.dat 文件是数据保存文件，请勿更改此文件的存放位置！\n");
        printf("\n否则将会造成数据丢失！\n\n");
    }
    
    /*界面输出函数*/
    void Interface_output(void)
    {
        
        printf("\t\t\t\t************************************************\n");
        printf("\t\t\t\t*****       欢迎使用学生信息管理系统      ******\n");
        printf("\t\t\t\t***** 1. 添加学生信息 2. 输出所有学生信息 ******\n");
        printf("\t\t\t\t***** 3. 修改学生信息 4. 学生成绩排序     ******\n");
        printf("\t\t\t\t***** 5. 删除学生信息 6. 查找学生信息     ******\n");
        printf("\t\t\t\t***** 9. 清除所有数据 0. 退出系统         ******\n");
        printf("\t\t\t\t***** 7. 提示         ps:制作者：太平     ******\n");
        printf("\t\t\t\t************************************************\n");
    }

### 函数注释部分 ###

/*数据初始化函数*/
    1. void initialize(NODE *phead);
    /*
        返回值：空
        形象：NODE * 指针 
        用法：传入一个头结点的地址。
        作用：将头结点的 NODE *Next指针指向NULL，头结点本身没有初始化
    */
    
    /*文件数据加载函数*/
    2. void File_loading(NODE *phead);
    /*
        返回值：空
        形象：NODE * 指针 
        用法：一般用在initialize内，当头结点指针完成初始化后传入本函数
        作用：当完成初始化的头结点指针传入后，本函数会打开数据存储文件
                  然后会读取文件数据进行数据载入，读取一次将会建立一个链表结点 
                  将读取的数据依次存入链表的结点中，
                  直到文件数据读取完毕，链表尾结点指针指向NULL
    */
    
    /*菜单界面输出函数*/
    3. void Interface_output(void); 
    /*
        返回值：空
        形象：无
        用法：无需传入形参
        作用：将菜单界面输出
    */
    
    /*创建函数*/
    4. void create_list(NODE *phead);
    /*
        返回值：空
        形象：NODE *
        用法：需要传入头结点地址，进行数据操作
        作用：进行链表的结点创建，存储用户输入的数据，
                  如果链表已有结点，将会先进行指针的后移，直至指针指向链表的尾结点，然会进行结点的生成与链接
                  如果链表内没有结点，将直接开始链表结点的生成与链接
    */
    
    /*计算学生成绩总分与平均分*/
    5. void Calculate_Total_Score(NODE *phead);
    /*
        返回值：空
        形象：NODE * 类型指针
        用法：需要传入头结点的地址
        作用：从首结点开始，依次读取 链表结点内的学生成绩，进行学生总分与三科成绩的计算
                  将计算的结果赋值回学生成绩结构体中的 Total_score 与 Average_score成员 
                  Total_score ：储存学生的成绩总分
                  Average_score：储存学生成绩的平均分
    */
    
    /*遍历输出函数*/
    6. void traverse_list(const NODE *phead);
    /*
        返回值：空
        形象：NODE * 类型指针
        用法：需要传入头结点的地址
        作用：从首结点开始，依次遍历链表的每一个结点并输出结点内的所有数据
    */
    
    /*修改结点内容函数*/
    7. void Modify_the_data(NODE *phead);
    /*
        返回值：空
        形象：NODE * 类型指针
        用法：需要传入头结点的地址
        作用：使用学生姓名为关键字以进行查找，学生姓名由用户输入
                  函数内部使用了 strcmp字符串库函数，用于进行字符串的比较
                  将依次遍历链表所有结点，判断是否有和关键字相同的数据
                 有则对那个结点的数据进行，数据修改，修改的数据由用户动态输入
    */
    
    /*学生成绩排序*/
    8. void Student_sort(NODE *phead);
    /*
        返回值：空
        形象：NODE * 类型指针
        用法：需要传入头结点的地址
        作用：根据用户的功能选择不同的链表排序方式
                  用户选择功能后，将 头结点地址 与 用户选择的功能序号 传入Rank_sqrt函数中进行排序
                  Rank_sqrt函数为本函数的子函数
    */
    
    /*根据形参进行排序*/
    9. void Rank_sqrt(NODE *phead,int key);
    /*
        返回值：空
        形象：NODE * 类型指针，int key
        用法：需要传入头结点的地址 与 用户选择的功能序号
        作用：根据传入形参 key不同 而进行不同排序
    */
    
    /*计算链表长度 返回值为 int */
    10. int Lsit_len(NODE *phead);
    /*
        返回值：返回链表长度，一个int 类型的值
        形象：NODE * 类型指针
        用法：需要传入头结点的地址
        作用：获取链表的长度，或者说链表结点的个数
                  此函数计算的链表长度，不包括头结点，从首结点开始
    */
    
    /*删除数据函数*/
    11. void Delete_data(NODE *phead);
    /*
        返回值：无
        形象：NODE * 类型指针
        用法：需要传入头结点的地址
        作用：根据用户输入的关键字，进行循环判断，此函数使用了 strcmp字符串库函数
                  若遍历到某个节点的数据与之关键字相同，则删除那个结点，并释放那个结点的空间
                  如无，则退出
    */
    
    /*查找函数*/
    12. void Find_data(NODE *phead)；
    /*
        返回值：无
        形象：NODE * 类型指针
        用法：需要传入头结点的地址
        作用：获取用户正确输入的功能序号，将头结点与功能序号一并传入 traverse_Find 函数中
                  traverse_Find 是本函数的子函数，traverse_Find 才是查找输出的功能实现函数
    */
    
    /*遍历查找并输出*/
    13. void traverse_Find(NODE *phead,unsigned int key);
    /*
        返回值：无
        形象：NODE * 类型指针 与 unsigned int 类型的变量
        用法：需要传入头结点的地址 与 用户输入的功能序号
        作用：根据传入的功能序号的不同，进行不同的查找，
                  并使用 PUT_list_data 函数输出查找结果
                  PUT_list_data 函数为本函数的子函数         
    */
    
    /*数据输出函数*/
    14. void PUT_list_data(NODE *p_node);
    /*
        返回值：无
        形象：NODE * 类型指针
        用法：需要传入一个 链表结点 
        作用：输出传入的形参结点内所有数据，仅输出一次传入的链表结点数据
    */
    
    /*清空数据函数*/
    15. void Empty_data(NODE *phead,unsigned int key);
    /*
        返回值：无
        形象：NODE * 类型指针 与 unsigned int 类型的变量
        用法：需要传入一个 头结点 与 一个判断值 key
        作用：key 值是0的话 将清空链表与数据文件内的所有数据
                  key 值是1的话 只清空链表的数据，不清除数据文件内的数据
                  依次释放链表结点动态申请的空间，并将头结点进行一次初始化
    */
    
    /*数据保存到文件内的函数*/
    16. void Data_saving(NODE *phead);
    /*
        返回值：无
        形象：NODE * 类型指针
        用法：需要传入一个 头结点
        作用：将链表结点的数据依次保存到 Data_storage.dat 数据文件中
    */

以上就是整个学生信息管理系统的程序了，写的比较简陋，如有问题欢迎指出。