C语言实现新生入学登记系统

#ifndef SYSTEM_H_INCLUDED
#define SYSTEM_H_INCLUDED
//宏定义学生信息的一种表示形式
#define STUDENT_DATA  pMove->studentData.studentId,pMove->studentData.name,pMove->studentData.sex,pMove->studentData.age,pMove->studentData.className,pMove->studentData.major,pMove->studentData.tel,pMove->studentData.score

#define STUDENT_RANKING stuRanking[j].studentId, stuRanking[j].name, stuRanking[j].className, stuRanking[j].score,stuRanking[j].ranking
struct student
{
      char studentId[15];  //学号
      char name[10];
      char sex[4];
      int  age;
      char className[20];  //班级
      char major[20];  //专业
      char tel[15];
      int  score;    //入学成绩
};

struct node
{
      struct student studentData;
      struct Node* next;
};

struct studentRanking
{
     char studentId[15];
     char name[10];
     char className[20];
     int  score;
     int  ranking;

};
extern struct Node* studentList;  //链表的头指针
#endif // SYSTEM_H_INCLUDED

#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED
#include "AddStudent.h"
#include "BeginingAndEnding.h"
#include "DeleteStudent.h"
#include "ModifyStudent.h"
#include "SearchStudent.h"
#include "ShowStudent.h"
#include "ShowStudentRanking.h"
#include "MyList.h"
#include "system.h"
void showMenu();

#endif // MAIN_H_INCLUDED

#include <stdio.h>
#include <stdlib.h>
#include <coNIO.h>   //getc函数使用的头文件
#include "main.h"
//主函数
int main()
{
int selection;
Int ret;
    Begining();
    showMenu();      //展示界面
    ret = scanf("%d", &selection); //读入用户输入数字
getchar();
While(ret != 1)
{
     printf(“输入错误，请选择（0-6）：”)；
     ret = scanf("%d", &selection); //读入用户输入数字
}
    while (selection)
    {
        switch (selection)
        {
        case 1:
            AddStudent();  //录入学生信息
            break;
        case 2:
            ShowStudent();  //浏览学生信息
            break;
        case 3:
            SearchStudent(); //查找学生信息
            break;
        case 4:
            DeleteStudent(); //删除学生信息
            break;
        case 5:
            ModifyStudent();//修改学生信息
            break;
        case 6:
            ShowRanking(); //显示学生排名
            break;
        default:
            printf("\t\t请输入正确的数字！\n");
        }
        Ending(); //将链表数据写入文件
        printf("|按任意键返回系统菜单|");
        getch(); //接收用户输入的任意字符
        system("cls");
        showMenu();
        ret = scanf("%d", &selection); //提示用户输入数字
        getchar();
    While(ret != 1)
{
        printf(“输入错误，请选择（0-6）：”)；
        ret = scanf("%d", &selection); //读入用户输入数字
}

    }
    return 0;
}


void showMenu()
{

    printf("\n\n\n\n\n");
    printf("\t|--------------- 欢迎进入 ----------------|\n");
    printf("\t|             新生入学登记系统            |\n");
    printf("\t|                 主菜单                  |\n");
    printf("\t|            1. 录入学生信息              |\n");
    printf("\t|            2. 浏览学生信息              |\n");
    printf("\t|            3. 查找学生信息              |\n");
    printf("\t|            4. 删除学生信息              |\n");
    printf("\t|            5. 修改学生信息              |\n");
    printf("\t|            6. 新生入学排名              |\n");
    printf("\t|            0. 退出系统                  |\n");
    printf("\t|-----------------------------------------|\n");
    printf("\n");
    printf("\t\t请选择(0-6):");
}

#ifndef BEGININGANDENDING_H_INCLUDED
#define BEGININGANDENDING_H_INCLUDED
//关于启动函数和结束函数
void Begining();
void Ending();
#endif // BEGININGANDENDING_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include "system.h"
#include "AboutFiles.h"
#include "BeginingAndEnding.h"
#include "MyList.h"
void Begining()
{
      readInfoFromFile("studentList.txt");
}
void Ending()
{
      writeInfoToFile("studentList.txt");
}

#ifndef MYLIST_H_INCLUDED
#define MYLIST_H_INCLUDED
//关于链表的函数声明
//创建节点
struct Node* createNode(struct student data);
//插入节点
void insertNodeByHead(struct student data);
//指定位置删除节点
void deleteAppointNode(char* studentId);
//查找功能
struct Node* searchInfoByData(char* studentId);
//打印链表
void printList();
#endif // MYLIST_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "system.h"
#include "MyList.h"

struct Node* studentList = NULL;  //链表的头指针
//创建节点
struct Node* createNode(struct student studentData)
{
      struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
      if(newNode != NULL)
      {
            newNode->studentData = studentData;
            newNode->next = NULL;
      }
      return newNode;
}
//插入节点
void insertNodeByHead(struct student data)
{
      struct Node* newNode = createNode(data);
      //表头法插入,每次插入都将数据插入到头节点的下一个，先判断头节点是否为空，为空则新节点就是头节点，不为空，则插入在头节点的下一个位置
      if(studentList == NULL)
      {
            studentList = newNode;
      }
      else//不改变头节点
      {
            newNode->next = studentList->next;
            studentList->next = newNode;
      }

}

//指定位置删除节点（知道这个节点的前驱和后续，然后进行删除）
void deleteAppointNode( char* studentId)
{
    //将链表头部设为指定位置，先判断头节点是否为空，为空则链表没有数据，无法删除
    //如果头节点不为空，则设头结点为指定位置，如果头结点是所找的节点，则删除，如果不是，设头结点的下一个为指定节点，头结点为指定节点的前驱节点，一直向下查询
    //指定位置
    struct Node* posNode = studentList;
    //指定位置的前面
    struct Node* posFrontNode = NULL;
    //查找指定节点
    if(posNode == NULL)
    {
       printf("数据为空无法删除！\n");
        return;
    }
    else
    {
          //姓名是字符串，不能直接比较， strcmp(), 相等返回值为0，相同返回值为负数或者正数
        if(strcmp(posNode->studentData.studentId, studentId) ==0)
        {
            studentList = studentList->next;
            free(posNode);
            return;
        }
        else
        {
            posFrontNode = posNode;
            posNode = posNode->next;
            //posFrontNode = posNode; //!!
            while(strcmp(posNode->studentData.studentId, studentId))
            {
                //继续向下一个节点移动
                posFrontNode = posNode;
                posNode = posFrontNode->next;
                if(posNode == NULL) //找到了链表尾部，没有找到数据
                {
                    printf("未找到指定位置，无法删除！");
                    return;
                }
            }
            //查到到对应数据后，进行删除，将该节点架空，然后释放该节点的存储单元
            posFrontNode->next = posNode->next;
            free(posNode);
            return;
        }
    }
}
//查找功能
struct Node* searchInfoByData(char* studentId)
{
      struct Node* pMove;
      pMove = studentList;
      if(pMove == NULL) //头节点为空，链表为空
      {
            //printf("学生链表为空！\n");
            return pMove;
      }
      else
      {
            // 查找到或者查找到链表最后，则结束循环，返回查询结果，结果为空，有两种可能，一种是链表中没有数据，另一种是没有查询到
            while(pMove != NULL)
            {
                  if(strcmp(pMove->studentData.studentId, studentId)==0)//找见
                  {
                        //printf("已查找到！\n");
                        return pMove;
                  }
                  else
                  {
                        pMove = pMove->next;
                  }

            }
            //printf("未找到!\n");
            return pMove;
      }
}

//打印链表
void printList()
{
      struct Node* pMove = studentList;
      //涉及到展示数据
      //表头
      if(pMove == NULL)
      {
            printf("No student record! Please add.\n");
            return;
      }
      else
      {
             printf("\t-------------------------------------------------------------------------------------\n");
printf("\t|%-10s |%-7s |%-4s |%-4s |%-12s |%-12s |%-12s |%-5s|\n","学号","姓名","性别","年龄","班级","专业","电话","入学成绩");
             printf("\t-------------------------------------------------------------------------------------\n");
while(pMove)
   {
      printf("\t|%-10s |%-7s |%-4s |%-4d |%-12s |%-12s |%-12s |%-8d|\n", STUDENT_DATA);
                  printf("\t-------------------------------------------------------------------------------------\n");
    pMove = pMove->next;
            }
      }
      printf("\n");
}

#ifndef ADDSTUDENT_H_INCLUDED
#define ADDSTUDENT_H_INCLUDED
void AddStudent();  //录入学生信息
#endif // ADDSTUDENT_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "AddStudent.h"
#include "system.h"
#include  "MyList.h"

//录入学生信息
void AddStudent()
{
    struct student studentData;
    struct Node* isNull = NULL;  //接收查询的返回值
    int iFlagExist;  //保证不重复输入
    char cFlag;
    int ret;  //用来接收scanf的返回值，判断输入数据是否正确

    system("cls");
    printf("===================================【录入学生信息】===============================\n");

    printf("\n请选择是否输入学生信息(y/n):");
    cFlag = getchar();
    getchar();
    while(cFlag != 'n' && cFlag!='y')
    {
          printf("输入有误，请输入‘y'或者‘n'!");
          printf("\n请选择是否输入学生信息(y/n):");
          cFlag = getchar();
          getchar();
    }
    if (cFlag == 'n')
        return;

    //循环输入学生信息可输入一条也可多条输入
    while (cFlag == 'y')
    {
        printf("请输入学生学号：");
        do
        {
            iFlagExist = 0;
            gets(studentData.studentId);
            //对学生编号在链表中进行查询，对查询结果进行判断，如果存在则重新输入，不存在则继续
            isNull = searchInfoByData(studentData.studentId);
            if(isNull!= NULL) //可以查询到
            {
                  printf("该学生已经存在请重新输入！\n");
                  printf("请输入学生学号：");
                  iFlagExist = 1;
            }
        } while (iFlagExist == 1);

        //添加学生信息
        printf("请输入学生姓名：");
        ret = scanf("%s",studentData.name);
        while(ret!=1)
        {
              printf("输入学生姓名有误，请重新输入！\n");
              printf("请输入学生姓名：");
              ret = scanf("%s",studentData.name);
        }
        getchar();
        printf("请输入学生性别（男-M，女-F）:"); //这里采用防御式编程，如果不是M,F或者没有输入该项则重新输入
        while (gets(studentData.sex) != NULL)
        {
            if (strcmp(studentData.sex, "F")==0 || strcmp(studentData.sex, "M")==0)
                break;
            printf("错误，只能输入'F'或者'M'，请重新输入\n");
            printf("请输入学生性别（男-M，女-F）：");
        }

        printf("请输入学生年龄(15-25)：");
        ret = scanf("%d", &studentData.age);
        while((ret != 1) || studentData.age<15 || studentData.age>25)
        {
              printf("输入年龄错误，请重新输入学生年龄(15-25)：");
              ret = scanf("%d", &studentData.age);
        }

        getchar();
        printf("请输入学生班级(eg: B电子191)：");
        gets(studentData.className);
        printf("请输入学生专业：");
        gets(studentData.major);
        printf("请输入学生电话：");
        gets(studentData.tel);

        printf("请输入学生入学成绩（200-750）：");
        ret = scanf("%d", &studentData.score);
        while((ret != 1) || studentData.score<200 || studentData.score>750)
        {
              printf("输入成绩信息错误，请重新输入学生入学成绩(200-750)：");
              ret = scanf("%d", &studentData.score);
        }
        getchar();

        insertNodeByHead(studentData);
        fflush(stdin);
        printf("继续输入信息吗(y/n):");
        cFlag = getchar();
        getchar();
        while(cFlag != 'n' && cFlag!='y')
        {
            printf("输入有误，请输入‘y'或者‘n'!");
            printf("\n请选择是否输入学生信息(y/n):");
            cFlag = getchar();
            getchar();
        }
    }
    printf("添加学生信息执行完毕！\n");
}

#ifndef SHOWSTUDENT_H_INCLUDED
#define SHOWSTUDENT_H_INCLUDED
void ShowStudent(); //查找学生信息
#endif // SHOWSTUDENT_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "ShowStudent.h"
#include "system.h"
#include  "MyList.h"
//浏览学生信息
void ShowStudent()
{
      system("cls");
      printf("\n");
      printf("\t====================================【浏览学生信息】================================\n");
      printf("\n\n");
      printList();

}

#ifndef SEARCHSTUDENT_H_INCLUDED
#define SEARCHSTUDENT_H_INCLUDED
void SearchStudent(); //查找学生信息
#endif // SEARCHSTUDENT_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "SearchStudent.h"
#include "system.h"
#include  "MyList.h"

//查找学生信息
void SearchStudent()
{
      //查询成功，则返回该学生信息，查询失败则输出提示信息，可重新输入，也可退出
      struct student studentData;
      struct Node* pMove = NULL; //用来接收查询返回的结果
      char cFlag;  //接收用户的选择

      system("cls");
      printf("\n");
      printf("\t==================================【查找学生信息】==============================\n");

      printf("\t是否进行学生查询（y/n）：");
      cFlag = getchar();
      getchar(); //接收回车键
      while(cFlag != 'n' && cFlag!='y')
      {
            printf("输入有误，请输入‘y'或者‘n'!");
            printf("\n请选择是否查询学生信息(y/n):");
            cFlag = getchar();
            getchar();
      }
      if (cFlag == 'n')
        return;

      while(cFlag == 'y')
      {
        printf("\t请输入需要查找的学生的学号：");
        //这里通过学号进行查询，学号是唯一的，姓名有重名现象
        gets(studentData.studentId);
        pMove = searchInfoByData(studentData.studentId);
        if(pMove)  //pMove 为真时，表示查询到
        {
            printf("\t查询成功，以下为该学生信息:\n");
            printf("\t-------------------------------------------------------------------------------------\n");
            printf("\t|%-10s |%-7s |%-4s |%-4s |%-12s |%-12s |%-12s |%-5s|\n","学号","姓名","性别","年龄","班级","专业","电话","入学成绩");
            printf("\t-------------------------------------------------------------------------------------\n");
            printf("\t|%-10s |%-7s |%-4s |%-4d |%-12s |%-12s |%-12s |%-8d|\n", STUDENT_DATA);
            printf("\t-------------------------------------------------------------------------------------\n");

        }
        else //pMove 为空时，未查询到,这里为空有两种情况，一种为学生名单为空，一种是没有查询到
        {
            printf("\t查询失败，该学生不存在或学生列表为空！\n");
            printf("\t是否重新查询（y/n）:");
            cFlag = getchar();
            getchar();
            while(cFlag != 'n' && cFlag!='y')
            {
                printf("输入有误，请输入‘y'或者‘n'!");
                printf("\n是否重新查询学生信息(y/n):");
                cFlag = getchar();
                getchar();
            }
        }
      }
      printf("\t学生信息查询结束！\n");
}

#ifndef DELETESTUDENT_H_INCLUDED
#define DELETESTUDENT_H_INCLUDED
void DeleteStudent(); //删除学生信息
#endif // DELETESTUDENT_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "DeleteStudent.h"
#include "system.h"
#include  "MyList.h"
//删除学生信息
void DeleteStudent()
{
      //先根据学号对该学生进行查找，查找到则删除，没有查找到则输出提示信息
      struct student studentData;
      struct Node* pMove = NULL; //用来接收查询返回的结果
      char cFlag;

      system("cls");
      printf("\n");
      printf("\t==================================【删除学生信息】==============================\n");
      printf("\t请输入需要删除的学生的学号：");
      gets(studentData.studentId);
      pMove = searchInfoByData(studentData.studentId);
      if(pMove)  //该学生存在，进行删除
      {
        //先对学生信息进行展示
        printf("\t-------------------------------------------------------------------------------------\n");
        printf("\t|%-10s |%-7s |%-4s |%-4s |%-12s |%-12s |%-12s |%-5s|\n","学号","姓名","性别","年龄","班级","专业","电话","入学成绩");
        printf("\t-------------------------------------------------------------------------------------\n");
        printf("\t|%-10s |%-7s |%-4s |%-4d |%-12s |%-12s |%-12s |%-8d|\n", STUDENT_DATA);
        printf("\t-------------------------------------------------------------------------------------\n");
        printf("\t已查找到该学生信息，是否删除？(y/n)");
        cFlag = getchar();
        getchar(); //吃掉缓冲区的空格

        while(cFlag != 'n' && cFlag!='y')
        {
            printf("输入有误，请输入‘y'或者‘n'!");
            printf("\n请选择是否输入学生信息(y/n):");
            cFlag = getchar();
            getchar();
        }

        if(cFlag == 'n')
            return;
        else if(cFlag == 'y')
        {
              deleteAppointNode(studentData.studentId);
              printf("\t已删除该学生信息！\n");
              printf("\t删除操作执行结束！\n");
        }
      }
      else //找到了链表的末尾，或者链表为空
      {
        printf("\t该学生不存在！无法执行删除操作\n");
      }
}

#ifndef MODIFYSTUDENT_H_INCLUDED
#define MODIFYSTUDENT_H_INCLUDED
#include "system.h"
void ModifyStudent();//修改学生信息
void ShowModifyMenu();//展示修改选项菜单
void dealSelection(struct student studentData, int selection, struct Node *pMove); //处理用户选择的修改项
#endif // MODIFYSTUDENT_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "ModifyStudent.h"
#include "system.h"
#include "MyList.h"

//修改学生信息
void ModifyStudent()
{
      struct student studentData;
      struct Node* pMove = NULL; //对学生信息查询结果进行保存
      int selection;  //保存选择信息
      char isContinue = 'n';  //是否继续进行修改

      system("cls");
      printf("\n");
      printf("\t==================================【修改学生信息】==============================\n");

      printf("\t请输入需要修改信息的学生的学号:");
      gets(studentData.studentId);
      pMove = searchInfoByData(studentData.studentId);
      if(pMove == NULL)
      {
            printf("\t该学生信息不存在，无法进行信息修改\n");
            return;
      }
      else  //可修改多条学生信息，也可以只修改一条学生信息
      {
            printf("\t-------------------------------------------------------------------------------------\n");
            printf("\t|%-10s |%-7s |%-4s |%-4s |%-12s |%-12s |%-12s |%-5s|\n","学号","姓名","性别","年龄","班级","专业","电话","入学成绩");
            printf("\t-------------------------------------------------------------------------------------\n");
            printf("\t|%-10s |%-7s |%-4s |%-4d |%-12s |%-12s |%-12s |%-8d|\n", STUDENT_DATA);
            printf("\t-------------------------------------------------------------------------------------\n");

            printf("\t是否进行学生信息的修改？(y/n)");
            scanf("%c", &isContinue);
            getchar();
            while(isContinue != 'n' && isContinue !='y')
            {
                  printf("\t输入有误，请输入‘y'或者‘n'!");
                  printf("\t请选择是否修改学生信息(y/n):");
                  isContinue = getchar();
                  getchar();
            }
            if(isContinue == 'n')
                  return;
            else
            {
                  while(isContinue == 'y')
                  {
                        //system('cls');
                        ShowModifyMenu();
                        //printf("\t请选择修改项: ");

                        scanf("%d", &selection);
                        getchar();
                        //对用户的操作选择进行处理
                        dealSelection(studentData,selection,pMove);
                        fflush(stdin);
                        printf("\t是否继续修改学生信息（y/n）？");
                        isContinue = getchar();
                        getchar();
                        while(isContinue != 'n' && isContinue!='y')
                        {
                              printf("\n输入有误，请输入‘y'或者‘n'!");
                              printf("\n请选择是否继续修改学生信息(y/n):");
                              isContinue = getchar();
                              getchar();
                        }

                  }
                  printf("\t学生信息修改完毕！\n");
           }
      }

}

//学生信息修改菜单
void ShowModifyMenu()
{
    printf("\n");
    //printf("\t|              1.学号              |\n");
    printf("\t|              1.姓名              |\n");
    printf("\t|              2.性别              |\n");
    printf("\t|              3.年龄              |\n");
    printf("\t|              4.班级              |\n");
    printf("\t|              5.专业              |\n");
    printf("\t|              6.电话              |\n");
    printf("\t|              7.入学成绩          |\n");
    printf("\n");
    printf("请输入所要修改的信息（键入相应的数字：1-7）：");
}

//处理用户选择的修改项
void dealSelection(struct student studentData, int selection, struct Node* pMove)
{
    int ret; //用来接收scanf的返回值
    switch (selection)
    {
    case 1:
        printf("\t请输入输入学生姓名：");
        gets(studentData.name);
        strcpy(pMove->studentData.name, studentData.name);
        break;

    case 2:
        printf("\t请输入学生性别（男-M，女-F）：");
        while (gets(studentData.sex) != NULL)
        {
            if (strcmp(studentData.sex, "F") == 0 || strcmp(studentData.sex, "M") == 0)
                break;
            printf("\t错误，只能输入'F'或者'M'，请重新输入\n");
            printf("\t请输入学生性别（男-M，女-F）：");
        }
        strcpy(pMove->studentData.sex,studentData.sex);
        break;

    case 3:
        printf("\t请输入学生年龄(15-25)：");
        ret = scanf("%d", &studentData.age);
        while((ret != 1) || studentData.age<15 || studentData.age>25)
        {
              printf("\t输入年龄错误，请重新输入学生年龄(15-25)：");
              ret = scanf("%d", &studentData.age);
        }
        pMove->studentData.age = studentData.age;
        break;

    case 4:
        printf("\t请输入学生班级(eg:B电子191)：");
        gets(studentData.className);
        strcpy(pMove->studentData.className, studentData.className);
        break;

    case 5:
        printf("\t请输入学生专业：");
        gets(studentData.major);
        strcpy(pMove->studentData.major, studentData.major);
        break;

    case 6:
        printf("\t请输入学生电话：");
        gets(studentData.tel);
        strcpy(pMove->studentData.tel, studentData.tel);
        break;

    case 7:
        printf("\t请输入学生入学成绩(100-750)：");
        ret = scanf("%d", &studentData.score);
        while((ret != 1) || studentData.score<200 || studentData.score>750)
        {
              printf("\t输入成绩信息错误，请重新输入学生入学成绩(200-750)：");
              ret = scanf("%d", &studentData.score);
        }
        pMove->studentData.score = studentData.score;
        break;

    default:
        printf("\t\t请输入正确的数字!");
        break;

    }
}

#ifndef SHOWSTUDENTRANKING_H_INCLUDED
#define SHOWSTUDENTRANKING_H_INCLUDED
#include "system.h"
void ShowRanking(); //显示学生排名
void sortByScore(struct studentRanking * stuRanking, int length);
void Ranking(struct studentRanking * stuRanking, int length);
#endif // SHOWSTUDENTRANKING_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "ShowStudentRanking.h"
#include "system.h"

void ShowRanking()
{
      //*对链表中学生的成绩进行排名，并显示排名结果，排名结果括学号姓名班级专业入学成绩排名
      //*排名是struct studentRanking 的一个结构体成员，在得出排名后，再进行展示
      //*1.对链表中所有学生的成员进行排序，排序结果保存在student.ranking中
      //重新定义一个结构体，保存排名信息并输出
      //定义一个结构体数组
      struct Node *pMove = NULL;
      struct studentRanking *stuRanking;
      int i, j;
      int length = 0; //用来保存链表的长度

      system("cls");
      printf("\n");
      printf("\t==================================【学生排名信息】==============================\n");

      if(studentList == NULL)
      {
          printf("学生登记为空，无法进行成绩排名\n");
          return;
      }
      else //学生链表头指针不为空，代表学生链表中存有学生信息
      {
          pMove = studentList;  //pMove指向链表的头
          //通过遍历得到链表有多少个存储单元
          for(i=0; pMove != NULL; i++)
          {
             pMove = pMove->next;
          }
          length = i;
          printf("现有学生总人数为%d\n", length);

          //动态数组
          stuRanking = (struct studentRanking *)malloc(length * sizeof(struct studentRanking));
          if(stuRanking == NULL)
            return;
          //将需要输出的学生信息复制到结构体数组当中
          pMove = studentList;
          for(j=0; j<length; j++)
          {
                    strcpy(stuRanking[j].studentId, pMove->studentData.studentId);
                    strcpy(stuRanking[j].name , pMove->studentData.name);
                    strcpy(stuRanking[j].className , pMove->studentData.className);
                    stuRanking[j].score = pMove->studentData.score;
                    pMove = pMove->next;
          }
          //复制完成后，根据成绩对学生进行排序
          sortByScore(stuRanking, length);
          //根据排序结果，为每名同学添加排名信息
          Ranking(stuRanking, length);
          //展示排名
          printf("排名结果如下：\n");
          printf("\t-------------------------------------------------------\n");
          printf("\t|%-10s |%-7s |%-12s |%-5s |%-5s|\n","学号","姓名","班级","入学成绩","全级排名");
          printf("\t-------------------------------------------------------\n");

           for(j=0; j<length; j++)
          {
              printf("\t|%-10s |%-7s |%-12s |%-8d |%-8d|\n", STUDENT_RANKING);
              printf("\t-------------------------------------------------------\n");

          }

      }
      printf("输出排名信息完毕！\n");
      system("pause");
}

//通过成绩对链表中的数据进行排序
void sortByScore(struct studentRanking *stuRanking, int length)
{
    //进行冒泡排序，从大到小排序
    int i, j;
    struct studentRanking temp;
    for(i=0; i<length-1; i++)
    {
        for(j=0; j<(length-i-1); j++)
        {
            if(stuRanking[j].score < stuRanking[j+1].score)//后一项比前一项大，则交换两个存储单元中的数据，一轮排序下来，最小项就位，在列表的最末尾
            {
                temp = *(stuRanking+j);
                *(stuRanking+j) = *(stuRanking+j+1);
                *(stuRanking+j+1) =temp;
            }
        }

    }
}
void Ranking(struct studentRanking * stuRanking, int length)
{
      int i;
      for(i=1; i<=length; i++)
      {
            stuRanking[i-1].ranking = i;
      }
}

#ifndef ABOUTFILES_H_INCLUDED
#define ABOUTFILES_H_INCLUDED
//链表的读取--文件读操作
void readInfoFromFile(char* fileName);
//链表的存储--文件写操作
void writeInfoToFile(char* fileName);
#endif // ABOUTFILES_H_INCLUDED

#include <stdio.h>
#include <conio.h>   //getc函数使用的头文件
#include <windows.h> //Sleep函数使用的头文件
#include <string.h>//strcmp函数使用的头文
#include "system.h"
#include "AboutFiles.h"
#include  "MyList.h"

//链表的读取--文件读操作
void readInfoFromFile(char* fileName)
{
      //步骤：先将信息读到data里面，再将信息读到文件里面
      //1.打开文件
      FILE *fp;
      struct student data;
      fp = fopen(fileName, "r");

      if(fp == NULL)
      {
              fclose(fp);
              return NULL;

      }
      //2.读文件
      //格式化读取文件,没有读到文件结束标志，则一直读下去，读到的数据插入到链表里面
      else
      {
            while(fscanf(fp, "%s\t%s\t%s\t%d\t%s\t%s\t%s\t%d\n", data.studentId,data.name,data.sex,&data.age,data.className,data.major,data.tel,&data.score) != EOF)
            {
            //将文件中原来的数据插入到链表当中
                  insertNodeByHead(data);
            }
           //3.关闭文件,
           fclose(fp);
      }

}


//链表的存储--文件写操作
void writeInfoToFile(char* fileName)
{
      //1.打开文件D:\CodeBlocks\codeblocks C project\StudentSystemDemo02\studentList
      FILE *fp;
      struct Node* pMove = studentList;
      fp = fopen(fileName, "w");
      if(fp == NULL)
      {
            //w+具有创建的功能,建立一个新文件可读可写
            fp = fopen(fileName, "w+");
            //可以给文件写入一个表头信息
      }
      //2.写文件, 按格式写入操作
      while(pMove != NULL)
      {
            fprintf(fp,"%s\t%s\t%s\t%d\t%s\t%s\t%s\t%d\n", STUDENT_DATA);
            pMove = pMove->next;
      }

      //3.关闭文件
      fclose(fp);
}