学生成绩管理项目源代码

/**********************************************************************
*制作时间：2008年9月17日
*程序名称：学生成绩管理系统
*程序功能：能实现对学生成绩的录入，插入，删除，查找，浏览，排序，
*          合计，保存，读取等功能
***********************************************************************/

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

#define     STRSNO      "/n学生学号: "
#define     STRSNAME    "/n学生姓名: "
#define     STRC        "/nC企业要求与实践: "
#define     STRTD       "/nTD-SCDMA: "
#define     STRLINUX    "/nLinux 基础与开发: "
#define     STRJ        "/nJ2ME: "
#define     STREN       "/n专业英语: "

#define     CPRJ        0
#define     TD          1
#define     LINUX       2
#define     J2ME        3
#define     CSENG       4

#define     SUMSUBJ     5

#define     STRINPUTERROR   "输入有误,请重新输入!/n"

#define  PRINTTITLE  "/n     学号    | 姓  名 |C企业要求|TD-SCDMA|LINUX|J2ME|专业英语| 总分 | 平均  /n/n"

#define  PRINTSTYLE  " %s    %s/t   %d/t     %d/t    %d/t %d/t %d/t%d   %.2f/n"

#define     GETINPUTSTRDATA(str,data)    printf(str);     /
                                   scanf("%s",&data)

#define     GETINPUTINTDATA(str,data)    printf(str);     /
                                   scanf("%d",&data)

#define     CHECKINPUTFUNC(score)   if( score > 100 || score < 0 )    /
                              {                                 /
                               printf(STRINPUTERROR);        /
                               printf(STRC);                 /
                               scanf("%d",&score);           /
                              }
#define        INTTYPE        1
#define        FLOATTYPE      2
#define        STRTYPE        3

#define        OFFSETSNO        0
#define        OFFSETSNAME      (OFFSETSNO+16*sizeof(char))
#define        OFFSETSCORE      (OFFSETSNAME+12*sizeof(char))
#define        OFFSETSUM        (OFFSETSCORE+SUMSUBJ*sizeof(int))
#define        OFFSETAVR        (OFFSETSUM+sizeof(int))

/****************************************************************************
*******************用 system("color 0A"); ***********************************
*****其中color后面的0是背景色代号，A是前景色代号。各颜色代码如下： **********
****************************************************************************/
#define   USECOLORBLACK  system("color 00")   //0=黑色
#define   USECOLORBLUE  system("color 01")   //1=蓝色
#define   USECOLORGREEN  system("color 02")   //2=绿色
#define   USECOLORLBLUE  system("color 03")   //3=湖蓝色
#define   USECOLORRED      system("color 04")   //4=红色
#define   USECOLORPURPLE  system("color 05")   //5=紫色
#define   USECOLORYELLOW  system("color 06")   //6=黄色
#define   USECOLORWHITE  system("color 07")   //7=白色
#define   USECOLORDARK  system("color 08")   //8=灰色
#define   USECOLORSKYBLUE  system("color 09")   //9=淡蓝色
#define   USECOLORLGREEN  system("color 0A")   //A=淡绿色
#define   USECOLORLLGREEN  system("color 0B")   //B=淡浅绿色
#define   USECOLORLRED  system("color 0C")   //C=淡红色
#define   USECOLORLPURPLE  system("color 0D")   //D=淡紫色
#define   USECOLORLYELLOW  system("color 0E")   //E=淡黄色
#define   USECOLORHWHITE  system("color 0F")   //F=亮白色

// 结构体定义学生的所有属性，包括学生证号，姓名，5门学科成绩，总成绩，平均成绩
struct studentLink
{
 char       sno[16];
 char       sname[12];
 int        arscore[SUMSUBJ];
 int        sum;
 float      avr;
 struct studentLink* link;
};
typedef struct studentLink  STULINK;
    

// 函数声明
STULINK* creat();
STULINK* searchbysno(STULINK *head, char * sno, STULINK **prev);
void insert(STULINK *head,STULINK *p, STULINK stu);
void delstunode(STULINK *head,STULINK *prelink,STULINK *dellink);
void insertbysno(STULINK *head, STULINK stu);
void menu();        //主菜单函数
void input(STULINK *head);       //录入函数
void insertbysno(STULINK *head, STULINK stu);
void del(STULINK *head);         //删除函数
void delbysno(STULINK* head);       //按学生证号删除
void delbysname(STULINK* head);     //按姓名删除 
void select(STULINK* head);      //查找函数
void selectsno(STULINK* head);    //按学生证号查找
void selectsname(STULINK* head);  //按姓名查找
void sort(STULINK *head,int offset, int type);        //冒泡排序函数
void display(STULINK* head);     //制表格式函数
void total(STULINK* head);       //分类合计函数
void save(STULINK* head);        //保存函数
void load(STULINK* head);        //读取函数
void freelink(STULINK* head);
void sortready(STULINK* head);
void sortbyscore(STULINK* head);

 

// 主函数

int main(void)
{
 int in;        //选择功能的变量
 char ch='y';   //选择是否继续时的变量，(y / n)
 STULINK* stuhead=NULL;
 stuhead = creat();
 //USECOLORLLGREEN;
 if(stuhead==NULL)
        return 1;
    load(stuhead);
 do
 {
  menu(); 
  scanf("%d",&in);
  if(in<0 || in>7)
  {
   printf("/a输入有误，请在0～7之间选择！");
   continue;
  }
  else if(in==0)
        {
   printf("确定要退出程序吗？(y / n) ");
   scanf(" %c",&ch);
   printf("/n");
   if(ch=='Y' || ch=='y')
   {
    printf("谢谢您的使用，再见！");
    break;
   }
  }
  switch(in)
  {
   case 1:                                    //录入
    printf("/n-----------------------------    请输入学员信息    -----------------------------");
    input(stuhead);
    break;
   case 2:                                    //插入
    if(stuhead->sum!=0)
    {
     del(stuhead); 
    }
    else
    {
     printf("/a没有数据!/n");       //(如果学生人数为0,弹出此消息)
    }
    break;
   case 3:                                    //删除
    if(stuhead->sum!=0)
    {
     select(stuhead);
    }
    else
    {
     printf("/a没有数据!/n");
    }
    break;
   case 4:                                    //查找
    if(stuhead->sum!=0)
    {
     display(stuhead);
    }
    else
    {
     printf("/a没有数据!/n");
    }
    break;
   case 5:                                    //排序    
    if(stuhead->sum!=0)
    {
     sortready(stuhead);
     display(stuhead);
    }
    else
    {
     printf("/a没有数据!/n");
    }
    break;
   case 6:                                    //合计    
    if(stuhead->sum!=0)
    {
     total(stuhead);
    }
    else
    {
     printf("/a没有数据!/n");
    }
    break;
   case 7:                                    //保存
    save(stuhead);
    break;
      default :
    break;   
   }  
 }while(1); 
 freelink(stuhead);
 return 0;
}

/*建立单链表的函数*/
STULINK * creat()
{
    /* *head保存表头结点的指针，*p指向当前结点的前一个结点，*s指向当前结点*/
    STULINK *head;
    /*分配空间并检测*/
    if((head=(STULINK *)malloc(sizeof(STULINK)))==NULL)
    {
        printf("不能分配内存空间!");
        return head;
    }
    /*把表头结点的数据域置空*/
    head->sname[0]='/0';
    head->sno[0]='/0';
    head->avr=0;
    //记录学生总人数
    head->sum=0;
    head->arscore[CPRJ]=0;
    head->arscore[TD]=0;
    head->arscore[LINUX]=0;
    head->arscore[J2ME]=0;
    head->arscore[CSENG]=0;
    /*把表头结点的链域置空*/
    head->link=NULL;
    /*p指向表头结点*/
    return(head);
}

/*查找链表的函数，其中h指针是链表的表头指针，sno指针是要查找的学生的学号,
prev为要查找的学生的前一个节点的指针（主要在删除使使用）*/
STULINK * searchbysno(STULINK *head, char * sno, STULINK **prev)
{
    /*当前指针，指向要与所查找的学号比较的结点*/
    STULINK *p;
    /*保存结点数据域内学号的指针*/
    char *no;
    p=head->link;
    *prev=head;
    while(p!=NULL)
    {
        no = p->sno;
        /*把数据域里的学号与所要查找的学号比较，若相同则返回0，即条件成立*/
        if(strcmp(no, sno)==0)
            /*返回与所要查找结点的地址*/
            return(p);
        else
        {
            *prev=p;
            p=p->link;
        }
    }
    printf("没有查找到该数据!");
    return(NULL);
   
}

STULINK * searchbysname(STULINK *head, char * sname, STULINK **prev)
{
    /*当前指针，指向要与所查找的学生姓名比较的结点*/
    STULINK *p;
    /*保存结点数据域内学生姓名的指针*/
    char *name;
    p=head->link;
    *prev=head;
    while(p!=NULL)
    {
        name = p->sname;
        /*把数据域里的学号与所要查找的学生姓名比较，若相同则返回0，即条件成立*/
        if(strcmp(name, sname)==0)
            /*返回与所要查找结点的地址*/
            return(p);
        else
        {
            *prev=p;
            p=p->link;
        }
    }
   printf("没有查找到该数据!");
   return(NULL);
 
}

void insertbysno(STULINK *head, STULINK stu)
{
    STULINK *p, *n;
    p = head;
    n = p->link;
    while(n!=NULL)
    {
        if( strcmp( stu.sno, n->sno ) < 0 )
        {
            insert(head,p, stu);
            return;
        }
        p = n;
        n = p->link;
    }
    insert(head, p, stu);
}

/*插入函数，在指针p后插入*/
void insert(STULINK *head, STULINK *p, STULINK stu)
{ 
    /*指针s是保存新结点地址的*/
    STULINK *s;
    if((s= (STULINK *) malloc(sizeof(STULINK)))==NULL)
    {
        printf("不能分配内存空间!");
        exit(0);
    }
    /*把指针stuname所指向的数组元素拷贝给新结点的数据域*/
    strcpy(s->sname,stu.sname);
    strcpy(s->sno,stu.sno);
    s->avr = stu.avr;
    s->sum = stu.sum;
    memcpy(s->arscore, stu.arscore, SUMSUBJ*sizeof(int));
    head->sum++;
    /*把新结点的链域指向原来p结点的后继结点*/
    s->link=p->link;
    /*p结点的链域指向新结点*/
    p->link=s;
}

/*删除函数，其中dellink为要删除的结点的指针，prelink为要删除的结点的前一个结点的指针*/
void delstunode(STULINK *head, STULINK *prelink,STULINK *dellink)
{
    STULINK *s;
    s = dellink;
    prelink->link = dellink->link;
    free(s);
    head->sum--;
}

 

// 主菜单函数
void menu()
{
    printf("                     *****************************************/n");
    printf("                     |         学生成绩系统主菜单界面        |/n");
    printf("                     |                                       |/n");
    printf("                     |    1.录入学生成绩    5.排序学生成绩   |/n");
    printf("                     |                                       |/n");
    printf("                     |    2.删除学生成绩    6.合计学生成绩   |/n");
    printf("                     |                                       |/n");
    printf("                     |    3.查找学生成绩    7.存储学生成绩   |/n");
       printf("                     |                                       |/n");
    printf("                     |    4.浏览学生成绩    0.安全退出系统   |/n");
       printf("                     |                                       |/n");
    printf("                     |                                       |/n");
    printf("                     |----------->学生成绩管理程序<----------|/n");
    printf("                     *****************************************/n");
    printf("                               请在0～7之间选择 ：");     
}

// 录入函数
void input(STULINK *head)
{ 
 int i;
 char ch;
 STULINK s;
 do
    {  
  printf("/n------------------------    请输入要插入的学员信息    ------------------------");
        GETINPUTSTRDATA(STRSNO,s.sno);
  GETINPUTSTRDATA(STRSNAME,s.sname);
     
       
        GETINPUTINTDATA(STRC,s.arscore[CPRJ]);  
        CHECKINPUTFUNC(s.arscore[CPRJ]);
  
        GETINPUTINTDATA(STRTD,s.arscore[TD]);  
  CHECKINPUTFUNC(s.arscore[TD]);
  
  GETINPUTINTDATA(STRLINUX,s.arscore[LINUX]);  
  CHECKINPUTFUNC(s.arscore[LINUX]);
  
  GETINPUTINTDATA(STRJ,s.arscore[J2ME]);  
  CHECKINPUTFUNC(s.arscore[J2ME]);
  
  GETINPUTINTDATA(STREN,s.arscore[CSENG]);  
  CHECKINPUTFUNC(s.arscore[CSENG]);
  
  s.sum=0;
        for(i=0;i<SUMSUBJ;i++)
            s.sum+=s.arscore[i];
  s.avr=(float)(s.sum/5.0);
  printf("/n总成绩:%d",s.sum);
  printf("/n平均成绩:%lf",s.avr);
  printf("/n/n");
  insertbysno(head, s);
  printf("是否继续输入？(y / n)  ");
  scanf(" %c",&ch);
  printf("/n");
  if(ch!='Y' && ch!='y')
  {
   break;
  }
 }while(1);
 
}

 

 

// 删除函数，含子菜单：按学生证号删除，按姓名删除
void del(STULINK* head)
{
 int in;   
 do
 {
  printf("                            ************************/n");
  printf("                            |    1.按学生证号删除  |/n");
  printf("                            |                      |/n");
  printf("                            |    2.学生按姓名删除  |/n");
  printf("                            |                      |/n");
  printf("                            |    3.返回上一级菜单  |/n");
  printf("                            ************************/n");
  printf("                               请在1～3之间选择： ");
  scanf("%d",&in);
  if(in<1 || in>3)
  {
   printf("/a输入有误，请重新输入！/n");
   continue;
  }
  else
  {
   break;
  }
 }while(1);
 switch(in)
 {
  case 1:
   delbysno(head);
   break;
  case 2:
   delbysname(head);
   break;
  case 3:
   break;
  default:
            break;             
 }
}

// 删除函数，按学生证号删除
void delbysno(STULINK* head)
{
 STULINK *p, *pre;
    char strsno[15];
 char ch;
 p=NULL;
    pre=NULL;
    printf("/n--------------------    请输入要删除的学员的学生证号   ------------------------");
 do
  {
         printf("/n输入学号: ");
         scanf("%s",strsno);
         if(strlen(strsno)>15)
              printf("/n输入的学号超过规定长度，请重新输入！");
         else
         {
             p = searchbysno(head, strsno, &pre);
             if(p==NULL)
             {
                 printf("/n您所输入的学号并不存在 ！");
                 printf("/n需要重新输入请按(Y)键，其他任意键将放弃删除！");
                 scanf(" %c",&ch);
                 printf("/n");
                 if(ch!='y' && ch!='Y')
                     return;
             }
             else
                 break;
         }
     }while(1);
    
  printf(PRINTTITLE);
  printf(PRINTSTYLE, p->sno,p->sname,p->arscore[CPRJ],p->arscore[TD],
              p->arscore[LINUX],p->arscore[J2ME],p->arscore[CSENG],
              p->sum,p->avr);
  printf("/n确定要删除吗？(Y / N)");
  scanf(" %c",&ch);
  printf("/n");
  if(ch=='y' || ch=='Y')
     {
  delstunode(head, pre, p );
  printf("删除成功/n");
  
 
 }
}

// 删除函数，按学生姓名删除
void delbysname(STULINK* head)
{
 STULINK *p, *pre;
    char strsname[10];
 char ch;
 p=NULL;
    pre=NULL;
    printf("/n--------------------    请输入要删除的学生的姓名   ------------------------");
 do
  {
         printf("/n输入学号: ");
         scanf("%s",strsname);
         if(strlen(strsname)>10)
              printf("/n你输入的是日本人的名字吗？超过了规定长度，请重新输入！");
         else
         {
             p = searchbysname(head, strsname, &pre);
             if(p==NULL)
             {
                 printf("/n您所输入的学生姓名并不存在 ！");
                 printf("/n需要重新输入请按(Y)键，其他任意键将放弃删除！");
                 scanf(" %c",&ch);
                 printf("/n");
                 if(ch!='y' && ch!='Y')
                     return;
             }
             else
                 break;
         }
     }while(1);
    
  printf(PRINTTITLE);
  printf(PRINTSTYLE, p->sno,p->sname,p->arscore[CPRJ],p->arscore[TD],
              p->arscore[LINUX],p->arscore[J2ME],p->arscore[CSENG],
              p->sum,p->avr);
  printf("/n确定要删除吗？(Y / N)");
  scanf(" %c",&ch);
  printf("/n");
  if(ch=='y' || ch=='Y')
     {
  delstunode(head, pre, p );
  printf("删除成功/n");
 }
}

// 查找函数，含子程序：按学生证号查找，按姓名查找
void  select(STULINK* head)
{
 int in;   
 do
 {
  printf("                            ************************/n");
  printf("                            |    1.按学生证号查找  |/n");
  printf("                            |                      |/n");
  printf("                            |    2.按学生姓名查找  |/n");
  printf("                            |                      |/n");
  printf("                            |    3.返回上一级菜单  |/n");
  printf("                            ************************/n");
  printf("                               请在1～3之间选择： ");
  scanf("%d",&in);
  if(in<1 || in>3)
  {
   printf("/a输入有误，请重新输入！/n");
   continue;
  }
  else
  {
   break;
  }
 }while(1);
 switch(in)
 {
  case 1:
   selectsno(head);
   break;
  case 2:
   selectsname(head);
   break;
  case 3:
   break;
  default:
            break;
 }
}

// 查找函数，按学生证号查找学员信息
void selectsno(STULINK* head)
{
 STULINK *p, *pre;
    char strsno[15];
 char ch;
 p=NULL;
    pre=NULL;
    printf("/n--------------------    请输入要查询的学员的学生证号   ------------------------");
 do
  {
         printf("/n输入学号: ");
         scanf("%s",strsno);
         if(strlen(strsno)>15)
              printf("/n输入的学号超过规定长度，请重新输入！");
         else
         {
             p = searchbysno(head, strsno, &pre);
             if(p==NULL)
             {
                 printf("/n您所输入的学号并不存在 ！");
                 printf("/n需要重新输入请按(Y)键，其他任意键将放弃查询！");
                 scanf("%c",&ch);
                 printf("/n");
                 if(ch!='y' && ch!='Y')
                     return;
             }
             else
                 break;
         }
     }while(1);
    
   printf(PRINTTITLE);
  printf(PRINTSTYLE, p->sno,p->sname,p->arscore[CPRJ],p->arscore[TD],
              p->arscore[LINUX],p->arscore[J2ME],p->arscore[CSENG],
              p->sum,p->avr);
}

// 查找函数，按姓名查找学员信息
void selectsname(STULINK* head)
{
 STULINK *p, *pre;
    char strsname[10];
 char ch;
 p=NULL;
    pre=NULL;
    printf("/n--------------------    请输入要查询的学生的姓名   ------------------------");
 do
  {
         printf("/n输入学号: ");
         scanf("%s",strsname);
         if(strlen(strsname)>10)
              printf("/n你输入的是日本人的名字吗？超过了规定长度，请重新输入！");
         else
         {
             p = searchbysname(head, strsname, &pre);
             if(p==NULL)
             {
                 printf("/n您所输入的学生姓名并不存在 ！");
                 printf("/n需要重新输入请按(Y)键，其他任意键将放弃查询！");
                 scanf("%c",&ch);
                 printf("/n");
                 if(ch!='y' && ch!='Y')
                     return;
             }
             else
                 break;
         }
     }while(1);
    
   printf(PRINTTITLE);
  printf(PRINTSTYLE, p->sno,p->sname,p->arscore[CPRJ],p->arscore[TD],
              p->arscore[LINUX],p->arscore[J2ME],p->arscore[CSENG],
              p->sum,p->avr);
}
//按各门具体课程的成绩排序
void sortbyscore(STULINK* head)
{
    int in;   
 do
 {
  printf("                            ********************************/n");
  printf("                            |    下面是可排序的课程的名称  |/n");
  printf("                            |                              |/n");
  printf("                            |    1.C企业要求与实践         |/n");
  printf("                            |                              |/n");
  printf("                            |    2.TD-SCDMA                |/n");
  printf("                            |                              |/n");
  printf("                            |    3.LINUX                   |/n");
  printf("                            |                              |/n");
  printf("                            |    4.J2ME                    |/n");
  printf("                            |                              |/n");
  printf("                            |    5.专业英语                |/n");
  printf("                            |                              |/n");
  printf("                            |    6.返回上一级菜单          |/n");
  printf("                            ********************************/n");
  printf("                               请在1～6之间选择： ");
  scanf("%d",&in);
  if(in<1 || in>6)
  {
   printf("/a输入有误，请重新输入！/n");
   continue;
  }
  else
  {
   break;
  }
 }while(1);
 if( in != 6 )
   sort(head,OFFSETSCORE+(in-1)*sizeof(int), INTTYPE);
 }
// 排序界面函数，含子菜单：按学生证号排序，按姓名排序，按课程成绩排序（包括五门课程），按总成绩来排序
void sortready(STULINK* head)
{
 int in;   
 do
 {
  printf("                            ****************************/n");
  printf("                            |    1.按学生证号排序      |/n");
  printf("                            |                          |/n");
  printf("                            |    2.按学生姓名排序      |/n");
  printf("                            |                          |/n");
  printf("                            |    3.按学生单科成绩排序  |/n");
  printf("                            |                          |/n");
  printf("                            |    4.按学生总成绩排序    |/n");
  printf("                            |                          |/n");
  printf("                            |    5.返回上一级菜单      |/n");
  printf("                            ****************************/n");
  printf("                               请在1～5之间选择： ");
  scanf("%d",&in);
  if(in<1 || in>5)
  {
   printf("/a输入有误，请重新输入！/n");
   continue;
  }
  else
  {
   break;
  }
 }while(1);
 switch(in)
 {
  case 1:
   sort(head,OFFSETSNO, STRTYPE);
   break;
  case 2:
   sort(head, OFFSETSNAME, STRTYPE);
   break;
  case 3:
            sortbyscore(head);
   break;
  case 4:
            sort(head, OFFSETSUM, INTTYPE);
            break;
        case 5:
             break;
  default:
            break;             
 }
}

// 排序函数，按成绩从高到低排序,学号或姓名按字符由小到大排序
void sort(STULINK *head, int offset, int type)
{
 int i,j,sum;
 int *numdest,*numsrc;
 float *fdest, *fsrc;
 char *strdest,*strsrc;
 int isswap=0;
 STULINK *p,*q,*prev;
 sum=head->sum;
 
 for(i=0;i<sum-1;i++)
 {
        prev = head;
     p=head->link;
     q=p->link;
  for(j=0;j<sum-1-i;j++)
  {
   isswap = 0;
   switch(type)
   {
                case INTTYPE:
                     numsrc=(int*)((char*)p+offset);
                     numdest=(int*)((char*)q+offset);
                     if(*numsrc < *numdest )
                         isswap=1;
                     break;
                case FLOATTYPE:
                     fsrc=(float*)((char*)p+offset);
                     fdest=(float*)((char*)q+offset);
                     if(*fsrc < *fdest )
                         isswap=1;
                     break;
                case STRTYPE:
                     strsrc  = (char*)((char*)p+offset);
                     strdest = (char*)((char*)q+offset);
                     if( strcmp(strsrc,strdest)>0 )
                         isswap=1;
                     break;
                default:
                     return;
            }
            if( isswap == 1 )
            {
                p->link = q->link;
                q->link = p;
                prev->link = q;
                p = prev->link;
                q = p->link;
            }
            prev = prev->link;
            p = p->link;
            q = q->link;
  }
    }
}

// 制表函数，将所有学员成绩以表格形式输出
void display(STULINK* head)
{
 STULINK *p;
 printf("------------------------------------------------------");
 printf(PRINTTITLE);
 p=head->link;
    while(p!=NULL)
 {
        
  printf(PRINTSTYLE, p->sno,p->sname,p->arscore[CPRJ],p->arscore[TD],
              p->arscore[LINUX],p->arscore[J2ME],p->arscore[CSENG],
              p->sum,p->avr);
        p = p->link;
 }
 printf("------------------------------------------------------/n");
}

// 合计函数，将3门学科的个人成绩，总分，平均分输出
void total(STULINK* head)
{
 int i;
 int arsum[SUMSUBJ];
 float aravr[SUMSUBJ];
 int stusum=head->sum;
 STULINK *p;
 p = head->link;
    printf("/n/t班级总人数 | C企业要求与实践 | TD-SCDMA | LINUX | J2ME | 专业英语/n/n");
 for(i=0;i<SUMSUBJ;i++)
    {
  arsum[i]=0;
    }
    while(p!=NULL)
    {
        for(i=0;i<SUMSUBJ;i++)
        {
            arsum[i]+=p->arscore[i];
        }
        p = p->link; 
    }
    for(i=0;i<SUMSUBJ;i++)
    {
  aravr[i] = (float)arsum[i] / stusum;
    }
 printf("合计:/t    %d/t/t  %d/t/t %d/t   %d/t  %d/t  %d/n",stusum, arsum[0],arsum[1],arsum[2],arsum[3],arsum[4]);
 printf("平均分:/t/t/t  %.2f/t/t %.2f/t   %.2f  %.2f/t  %.2f/n",aravr[0],aravr[1],aravr[2],aravr[3],aravr[4]);
 printf("/n");
}

// 保存函数，将数据保存到student.dat文件下
void save(STULINK* head)
{
 FILE *fp;
 STULINK *p;
 
    fp=fopen("student.dat","w");
 if(fp==NULL)
    {
  printf("文件保存失败！/n"); 
  return;
 }
 else
    {
         p=head->link;
         while(p!=NULL)
      {
      fwrite(p,sizeof(STULINK),1,fp);
      p = p->link;
         }
         printf("数据成功保存到程序下的student.dat文件中！/n");
 }
 fclose(fp);
}

// 读取函数，提取student.txt文件中的数据
void load(STULINK* head)
{
 int i;
 FILE *fp;
 int counter=0;
 STULINK stu;
 STULINK* p;
 int readcount;
 fp=fopen("student.dat","r+");
 if(fp==NULL)
 {
  printf("/a文件打开失败！/n"); 
  return;
 }
 else
 {
  i=0;
  p = head;
  while((readcount=fread(&stu,sizeof(STULINK),1,fp))>0)
  {
   insert( head, p ,stu );
   i++;
  }
  head->sum = i;  //在读取循环过程中counter多加了一次，所以在循环结束后自身减1

  //  读取完毕后打印出来
        if( i > 0 )
  {
            sort(head, OFFSETSNO, STRTYPE);
   display(head);
  }
  
 } 
}
void freelink(STULINK* head)
{
     STULINK  *p, *q;
     p = head;
     while(p!=NULL)
     {
         q = p;
         p = p->link;
         free(q);
     }
    
}