1. 全栈程序员必看首页

学生成绩管理系统【C语言程序设计】

全栈程序员-站长 • • 未分类 • 阅读 42

一、功能实现：0、浏览学生信息1、输入学生信息2、增加学生信息3、修改学生信息4、删除学生信息5、按学号查询6

大家好，又见面了，我是你们的朋友全栈君。一、功能实现：

0、浏览学生信息
1、输入学生信息
2、增加学生信息
3、修改学生信息
4、删除学生信息
5、按学号查询
6、按班级查询
7、按姓名查询
8、按课堂名称查询
9、按总分高低排序
10、单科成绩排名
11、查询班级优秀率
12、清屏
13、退出系统

二、运用到的核心知识：

0、动态链表的创建、输出、查找、增加、修改、删除等

1、链表的冒泡排序

三、代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define lis struct stu
#define setup (lis *)malloc(sizeof(lis))

struct score
{
    float ord_scor;
    //expe_scor,exam_scor;//可增加学生单科各类成绩，为简便，在此忽略
};

struct stu
{
    int num;
    char name[10];
    struct score Chinese, Math, English, Physics, Chem, Bio;
    float fina_scor;
    lis *next;
};

lis *p;

lis *input()//输入学生信息
{
    lis *head, *tail;
    int cnt = 0;
    p = setup;
    printf( "学号  姓名  语文  数学  英语  物理  化学  生物\n" );
    scanf( "%d", &p->num );
    while( 1 )
    {
        if( p->num == 0 )
            break;
        cnt++;
        scanf( "%s%f%f%f%f%f%f", p->name, &( p->Chinese ).ord_scor, &( p->Math ).ord_scor, &( p->English ).ord_scor, &( p->Physics ).ord_scor, &( p->Chem ).ord_scor, &( p->Bio ).ord_scor );
        if( cnt == 1 )
        {
            head = tail = p;
        }
        else
        {
            tail->next = p;
            tail = p;
        }
        p = setup;
        scanf( "%d", &p->num );
    }
    tail->next = NULL;
    return ( head );
}

lis *alter( lis *head ) //修改学生信息
{
    float alt_num, alt_scor;
    int course;
    printf( "请输入要修改的学生学号（0代表结束）： " );
    scanf( "%f", &alt_num );
    while( alt_num != 0 )
    {
        p = head;
        while( p != NULL )
        {
            if( p->num != alt_num )
                p = p->next;
            else
                break;
        }
        if( p == NULL )
        {
            printf( "输入学号有错！请重新输入（0代表结束）： " );
        }
        else
        {
            printf( "请输入要修改的课程代表的编号（1-语文，2-数学，3-英语，4-物理，5-化学，6-生物,0-修改结束）： " );
            scanf( "%d", &course );
            while( course > 6 || course < 0 )
            {
                printf( "输入编号有错！请重新输入编号（0代表结束）： " );
                scanf( "%d", &course );
            }
            while( course != 0 )
            {
                if( course > 6 || course < 0 )
                    printf( "输入编号有错！请重新输入编号（0代表结束）： " );
                else
                {
                    p = head;
                    while( p != NULL )
                    {
                        if( p->num == alt_num )
                        {
                            printf( "请输入新成绩:\n" );
                            scanf( "%f", &alt_scor );
                            switch( course )
                            {
                            case 1:
                                ( p->Chinese ).ord_scor = alt_scor;
                                break;
                            case 2:
                                ( p->Math ).ord_scor = alt_scor;
                                break;
                            case 3:
                                ( p->English ).ord_scor = alt_scor;
                                break;
                            case 4:
                                ( p->Physics ).ord_scor = alt_scor;
                                break;
                            case 5:
                                ( p->Chem ).ord_scor = alt_scor;
                                break;
                            case 6:
                                ( p->Bio ).ord_scor = alt_scor;
                                break;
                            }
                        }
                        p = p->next;
                    }
                    printf( "若继续修改该学生成绩，请输入编号（0代表结束）： " );
                }
                scanf( "%d", &course );
            }
            printf( "请输入学号（0代表结束）： " );
        }
        scanf( "%f", &alt_num );
    }
    return ( head );
}

lis *add( lis *head ) //增加学生信息
{
    lis *tail, *z, *q;
    q = tail = head;
    while( q != NULL )
    {
        z = tail; //z指向倒数第二个结点
        tail = q;
        q = q->next;
    }           //tail->next==NULL
    p = setup;
    printf( "请增加学生信息（学号为0无效，且结束增加）:\n学号  姓名  语文  数学  英语  物理  化学  生物\n" );
    scanf( "%d%s%f%f%f%f%f%f", &p->num, p->name, &( p->Chinese ).ord_scor, &( p->Math ).ord_scor, &( p->English ).ord_scor, &( p->Physics ).ord_scor, &( p->Chem ).ord_scor, &( p->Bio ).ord_scor );
    int flag;
    while( p->num != 0 )
    {
        flag = 0;
        while( flag == 0 || flag == 1 )
        {
            q = head;
            while( q != NULL )
            {
                if( q->num == p->num ) //学号重复
                {
                    flag = 1;
                    break;
                }
                else
                    q = q->next;
            }
            if( flag == 1 )
            {
                flag = 0;
                printf( "已存在该学生，请重新输入：\n" );
                p = setup;
                scanf( "%d%s%f%f%f%f%f%f", &p->num, p->name, &( p->Chinese ).ord_scor, &( p->Math ).ord_scor, &( p->English ).ord_scor, &( p->Physics ).ord_scor, &( p->Chem ).ord_scor, &( p->Bio ).ord_scor );
            }
            else
                break;
        }
        z->next = p;
        p->next = tail;
        z = p;
        p = setup;
        scanf( "%d%s%f%f%f%f%f%f", &p->num, p->name, &( p->Chinese ).ord_scor, &( p->Math ).ord_scor, &( p->English ).ord_scor, &( p->Physics ).ord_scor, &( p->Chem ).ord_scor, &( p->Bio ).ord_scor );
    }
    return ( head );
}

lis *delet( lis *head ) //删除学生信息
{
    int del_num;
    lis *t;
    printf( "请输入要删除的成绩对应的学号（0表示删除结束）:\n" );
    scanf( "%d", &del_num );
    while( del_num )
    {
        p = head;
        while( p != NULL )
        {
            if( head->num == del_num )
            {
                head = p->next;
                break;
            }
            else if( p->num == del_num )
            {
                t->next = p->next;
                break;
            }
            t = p;
            p = p->next;
        }
        if( p == NULL )
            printf( "输入学号有错！请重新输入：\n" );
        scanf( "%d", &del_num );
    }
    return ( head );
}

void search_print( lis *p )
{
    printf( "%d%7s%8.2f%10.2f%10.2f%10.2f%10.2f%10.2f\n", p->num, p->name, ( p->Chinese ).ord_scor, ( p->Math ).ord_scor, ( p->English ).ord_scor, ( p->Physics ).ord_scor, ( p->Chem ).ord_scor, ( p->Bio ).ord_scor );
}

void search( lis *head, int key ) //各种方式查询学生信息
{
    lis *q = head;
    int sear_num, sear_class, sear_course, flag1 = 0, flag2 = 0;
    char sear_name[10];
    if( key == 5 )
    {
        printf( "请输入学号：" );
        scanf( "%d", &sear_num );
    }
    else if( key == 6 )
    {
        flag1 = 1;                      //标记按班级查询
        printf( "请输入班级：" );
        scanf( "%d", &sear_class );
    }
    else if( key == 7 )
    {
        printf( "请请输入姓名：" );
        scanf( "%s", sear_name );
    }
    else if( key == 8 )
    {
        flag2 = 1;                      //标记按课程查询
        printf( "请输入课程代表的编号（1-语文，2-数学，3-英语，4-物理，5-化学，6-生物）：" );
        scanf( "%d", &sear_course );
    }
    if( flag2 )                         //按课程查询
    {
        switch( sear_course )
        {
        case 1:
        {
            printf( "学号    姓名    语文\n" );
            while( q != NULL )
            {
                printf( "%d%7s%8.2f\n", q->num, q->name, ( q->Chinese ).ord_scor );
                q = q->next;
            }
        }
        break;
        case 2:
        {
            printf( "学号    姓名    数学\n" );
            while( q != NULL )
            {
                printf( "%d%7s%8.2f\n", q->num, q->name, ( q->Math ).ord_scor );
                q = q->next;
            }
        }
        break;
        case 3:
        {
            printf( "学号    姓名    英语\n" );
            while( q != NULL )
            {
                printf( "%d%7s%8.2f\n", q->num, q->name, ( q->English ).ord_scor );
                q = q->next;
            }
        }
        break;
        case 4:
        {
            printf( "学号    姓名    物理\n" );
            while( q != NULL )
            {
                printf( "%d%7s%8.2f\n", q->num, q->name, ( q->Physics ).ord_scor );
                q = q->next;
            }
        }
        break;
        case 5:
        {
            printf( "学号    姓名    化学\n" );
            while( q != NULL )
            {
                printf( "%d%7s%8.2f\n", q->num, q->name, ( q->Chem ).ord_scor );
                q = q->next;
            }
        }
        break;
        case 6:
        {
            printf( "学号    姓名    生物\n" );
            while( q != NULL )
            {
                printf( "%d%7s%8.2f\n", q->num, q->name, ( q->Bio ).ord_scor );
                q = q->next;
            }
        }
        break;
        default:
            printf( "输入错误！\n" );
        }
    }
    else
    {
        if( flag1 )                     //按班级查询
        {
            int flag3 = 0;              //标记是否有输入的班级
            while( q != NULL )
            {
                if( ( q->num ) / 100 == sear_class )
                {
                    flag3 = 1;
                    break;
                }
                q = q->next;
            }
            if( flag3 )
            {
                q = head; //q要指向头节点
                printf( "学号    姓名    语文    数学    英语    物理    化学    生物\n" );
                while( q != NULL )
                {
                    if( ( q->num ) / 100 == sear_class )
                        search_print( q );
                    q = q->next;
                }
            }
            else
                printf( "输入错误！\n" );
        }
        else                            //按学号或姓名查询
        {
            while( q != NULL )
            {
                if( q->num == sear_num )
                    break;
                if( strcmp( q->name, sear_name ) == 0 )
                    break;
                q = q->next;
            }
            if( q == NULL )
                printf( "输入错误！\n" );
            else
            {
                printf( "学号    姓名    语文    数学    英语    物理    化学    生物\n" );
                search_print( q );
            }
        }
    }
}

lis *bubble_sort( lis *head, int len, int key ) //冒泡排序
{
    lis *t = setup;
    int i = len;
    if( key == 100 ) //交换总分
    {
        while( i > 1 )
        {
            p = head;
            while( p->next != NULL )
            {
                if( p->fina_scor < ( p->next )->fina_scor )
                {
                    t->num = p->num; //交换学号
                    p->num = ( p->next )->num;
                    ( p->next )->num = t->num;
                    strcpy( t->name, p->name ); //交换姓名
                    strcpy( p->name, ( p->next )->name );
                    strcpy( ( p->next )->name, t->name );
                    t->fina_scor = p->fina_scor;
                    p->fina_scor = ( p->next )->fina_scor;
                    ( p->next )->fina_scor = t->fina_scor;
                }
                p = p->next;
            }
            i--;
        }
        return ( head );
    }
    else if( key == 1 ) //交换语分
    {
        while( i > 1 )
        {
            p = head;
            while( p->next != NULL )
            {
                if( ( p->Chinese ).ord_scor < ( ( p->next )->Chinese ).ord_scor )
                {
                    t->num = p->num; //交换学号
                    p->num = ( p->next )->num;
                    ( p->next )->num = t->num;
                    strcpy( t->name, p->name ); //交换姓名
                    strcpy( p->name, ( p->next )->name );
                    strcpy( ( p->next )->name, t->name );
                    ( t->Chinese ).ord_scor = ( p->Chinese ).ord_scor;
                    ( p->Chinese ).ord_scor = ( ( p->next )->Chinese ).ord_scor;
                    ( ( p->next )->Chinese ).ord_scor = ( t->Chinese ).ord_scor;
                }
                p = p->next;
            }
            i--;
        }
        return ( head );
    }
    else if( key == 2 ) //交换数分
    {
        while( i > 1 )
        {
            p = head;
            while( p->next != NULL )
            {
                if( ( p->Math ).ord_scor < ( ( p->next )->Math ).ord_scor )
                {
                    t->num = p->num; //交换学号
                    p->num = ( p->next )->num;
                    ( p->next )->num = t->num;
                    strcpy( t->name, p->name ); //交换姓名
                    strcpy( p->name, ( p->next )->name );
                    strcpy( ( p->next )->name, t->name );
                    ( t->Math ).ord_scor = ( p->Math ).ord_scor;
                    ( p->Math ).ord_scor = ( ( p->next )->Math ).ord_scor;
                    ( ( p->next )->Math ).ord_scor = ( t->Math ).ord_scor;
                }
                p = p->next;
            }
            i--;
        }
        return ( head );
    }
    else if( key == 3 ) //交换英分
    {
        while( i > 1 )
        {
            p = head;
            while( p->next != NULL )
            {
                if( ( p->English ).ord_scor < ( ( p->next )->English ).ord_scor )
                {
                    t->num = p->num; //交换学号
                    p->num = ( p->next )->num;
                    ( p->next )->num = t->num;
                    strcpy( t->name, p->name ); //交换姓名
                    strcpy( p->name, ( p->next )->name );
                    strcpy( ( p->next )->name, t->name );
                    ( t->English ).ord_scor = ( p->English ).ord_scor;
                    ( p->English ).ord_scor = ( ( p->next )->English ).ord_scor;
                    ( ( p->next )->English ).ord_scor = ( t->English ).ord_scor;
                }
                p = p->next;
            }
            i--;
        }
        return ( head );
    }
    else if( key == 4 ) //交换物分
    {
        while( i > 1 )
        {
            p = head;
            while( p->next != NULL )
            {
                if( ( p->Physics ).ord_scor < ( ( p->next )->Physics ).ord_scor )
                {
                    t->num = p->num; //交换学号
                    p->num = ( p->next )->num;
                    ( p->next )->num = t->num;
                    strcpy( t->name, p->name ); //交换姓名
                    strcpy( p->name, ( p->next )->name );
                    strcpy( ( p->next )->name, t->name );
                    ( t->Physics ).ord_scor = ( p->Physics ).ord_scor;
                    ( p->Physics ).ord_scor = ( ( p->next )->Physics ).ord_scor;
                    ( ( p->next )->Physics ).ord_scor = ( t->Physics ).ord_scor;
                }
                p = p->next;
            }
            i--;
        }
        return ( head );
    }
    else if( key == 5 ) //交换化分
    {
        while( i > 1 )
        {
            p = head;
            while( p->next != NULL )
            {
                if( ( p->Chem ).ord_scor < ( ( p->next )->Chem ).ord_scor )
                {
                    t->num = p->num; //交换学号
                    p->num = ( p->next )->num;
                    ( p->next )->num = t->num;
                    strcpy( t->name, p->name ); //交换姓名
                    strcpy( p->name, ( p->next )->name );
                    strcpy( ( p->next )->name, t->name );
                    ( t->Chem ).ord_scor = ( p->Chem ).ord_scor;
                    ( p->Chem ).ord_scor = ( ( p->next )->Chem ).ord_scor;
                    ( ( p->next )->Chem ).ord_scor = ( t->Chem ).ord_scor;
                }
                p = p->next;
            }
            i--;
        }
        return ( head );
    }
    else if( key == 6 ) //交换生分
    {
        while( i > 1 )
        {
            p = head;
            while( p->next != NULL )
            {
                if( ( p->Bio ).ord_scor < ( ( p->next )->Bio ).ord_scor )
                {
                    t->num = p->num; //交换学号
                    p->num = ( p->next )->num;
                    ( p->next )->num = t->num;
                    strcpy( t->name, p->name ); //交换姓名
                    strcpy( p->name, ( p->next )->name );
                    strcpy( ( p->next )->name, t->name );
                    ( t->Bio ).ord_scor = ( p->Bio ).ord_scor;
                    ( p->Bio ).ord_scor = ( ( p->next )->Bio ).ord_scor;
                    ( ( p->next )->Bio ).ord_scor = ( t->Bio ).ord_scor;
                }
                p = p->next;
            }
            i--;
        }
        return ( head );
    }
}

void final_score_sort( lis *head ) //按总分高低排序
{
    int cnt = 0, z = 100;
    p = head;
    while( p != NULL )
    {
        cnt++;
        p->fina_scor = ( p->Chinese ).ord_scor + ( p->Math ).ord_scor + ( p->English ).ord_scor + ( p->Physics ).ord_scor + ( p->Chem ).ord_scor + ( p->Bio ).ord_scor;
        p = p->next;
    }
    head = bubble_sort( head, cnt, z );
    printf( "名次    学号\t    姓名    总分\n" );
    cnt = 1;
    p = head;
    while( p != NULL )
    {
        printf( "%d\t%d\t%7s%8.2f\n", cnt++, p->num, p->name, p->fina_scor );
        p = p->next;
    }
}

void  single_course_sort( lis *head ) //单科成绩排名
{
    int select, cnt = 0;
    p = head;
    while( p != NULL )
    {
        cnt++;
        p = p->next;
    }
    printf( "请输入课程代表的编号（1-语文，2-数学，3-英语，4-物理，5-化学，6-生物）：" );
    scanf( "%d", &select );
    switch( select )
    {
    case 1:
    {
        head = bubble_sort( head, cnt, select );
        printf( "名次    学号\t    姓名    语文分数\n" );
        cnt = 1;
        p = head;
        while( p != NULL )
        {
            printf( "%d\t%d\t%7s%8.2f\n", cnt++, p->num, p->name, ( p->Chinese ).ord_scor );
            p = p->next;
        }
    }
    break;
    case 2:
    {
        head = bubble_sort( head, cnt, select );
        printf( "名次    学号\t    姓名    数学分数\n" );
        cnt = 1;
        p = head;
        while( p != NULL )
        {
            printf( "%d\t%d\t%7s%8.2f\n", cnt++, p->num, p->name, ( p->Math ).ord_scor );
            p = p->next;
        }
    }
    break;
    case 3:
    {
        head = bubble_sort( head, cnt, select );
        printf( "名次    学号\t    姓名    英语分数\n" );
        cnt = 1;
        p = head;
        while( p != NULL )
        {
            printf( "%d\t%d\t%7s%8.2f\n", cnt++, p->num, p->name, ( p->English ).ord_scor );
            p = p->next;
        }
    }
    break;
    case 4:
    {
        head = bubble_sort( head, cnt, select );
        printf( "名次    学号\t    姓名    物理分数\n" );
        cnt = 1;
        p = head;
        while( p != NULL )
        {
            printf( "%d\t%d\t%7s%8.2f\n", cnt++, p->num, p->name, ( p->Physics ).ord_scor );
            p = p->next;
        }
    }
    break;
    case 5:
    {
        head = bubble_sort( head, cnt, select );
        printf( "名次    学号\t    姓名    化学分数\n" );
        cnt = 1;
        p = head;
        while( p != NULL )
        {
            printf( "%d\t%d\t%7s%8.2f\n", cnt++, p->num, p->name, ( p->Chem ).ord_scor );
            p = p->next;
        }
    }
    break;
    case 6:
    {
        head = bubble_sort( head, cnt, select );
        printf( "名次    学号\t    姓名    生物分数\n" );
        cnt = 1;
        p = head;
        while( p != NULL )
        {
            printf( "%d\t%d\t%7s%8.2f\n", cnt++, p->num, p->name, ( p->Bio ).ord_scor );
            p = p->next;
        }
    }
    break;
    default:
        printf( "输入错误！\n" );
    }
}

struct class_excel_rate
{
    int class_num, all_stu, excel_stu;
    struct class_excel_rate *next;
};

void bubble_sort_print( struct class_excel_rate *head, int lenth ) //冒泡排序并输出班级优秀率
{
    struct class_excel_rate *t = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
    int len = 0;
    float s;
    t = head;
    while( t != NULL )
    {
        len++;
        t = t->next;
    }
    while( len > 1 )
    {
        t = head;
        while( t->next != NULL )
        {
            if( ( t->next )->excel_stu / ( ( t->next )->all_stu * 0.1 ) > t->excel_stu / ( t->all_stu * 0.1 ) )
            {
                s = t->excel_stu;
                t->excel_stu = ( t->next )->excel_stu;
                ( t->next )->excel_stu = s;
                s = t->all_stu;
                t->all_stu = ( t->next )->all_stu;
                ( t->next )->all_stu = s;
            }
            t = t->next;
        }
        len--;
    }
    printf( "名次\t班级\t     总人数    优秀人数    优秀率\n" );
    int i = 1;
    t = head;
    while( t != NULL )
    {
        printf( "%d\t%d\t\t%d\t  %d\t   %.2f%%\n", i++, t->class_num, t->all_stu, t->excel_stu, t->excel_stu / ( t->all_stu * 0.1 ) * 10 );
        t = t->next;
    }
}

void select_class_find( lis *head, int len, int key ) //查询班级优秀率
{
    struct class_excel_rate *head1, *q, *r, *k; //创建新链表
    switch( key )
    {
    case 1://查询语文
    {
        p = head;
        head1 = q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
        head1->class_num = p->num / 100; //初始化头节点
        head1->all_stu = 1;
        if( ( p->Chinese ).ord_scor >= 90.0 )
            head1->excel_stu = 1;
        else
            head1->excel_stu = 0;
        p = p->next;
        while( p->next != NULL ) //先建立两个两个首、尾结点,以便其它班级的插入
        {
            if( p->num / 100 == head1->class_num ) //相同班级
            {
                head1->all_stu++;
                if( ( p->Chinese ).ord_scor >= 90.0 )
                    head1->excel_stu++;
            }
            else
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Chinese ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                head1->next = q;
                q->next = NULL;
                break;//建立链尾结点
            }
            p = p->next;
        }
        p = p->next;
        while( p != NULL ) //检索所有剩余的班级
        {
            r = k = head1; //问题：最后一个班级检索没有被处理
            while( r != NULL ) //检索班级是否相同
            {
                if( p->num / 100 == r->class_num )
                {
                    r->all_stu++;
                    if( ( p->Chinese ).ord_scor >= 90.0 )
                        r->excel_stu++;
                    break;
                }
                else
                {
                    k = r;
                    r = r->next;
                }
            }
            if( r == NULL ) //没有相同的班级，插入新结点
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Chinese ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                k->next = q;
                q->next = r;
            }
            p = p->next; //检索下一个处理的班级
        }
        bubble_sort_print( head1, len );
    }
    break;
    case 2://查询数学
    {
        p = head;
        head1 = q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
        head1->class_num = p->num / 100; //初始化头节点
        head1->all_stu = 1;
        if( ( p->Math ).ord_scor >= 90.0 )
            head1->excel_stu = 1;
        else
            head1->excel_stu = 0;
        p = p->next;
        while( p->next != NULL ) //先建立两个两个首、尾结点,以便其它班级的插入
        {
            if( p->num / 100 == head1->class_num ) //相同班级
            {
                head1->all_stu++;
                if( ( p->Math ).ord_scor >= 90.0 )
                    head1->excel_stu++;
            }
            else
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Math ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                head1->next = q;
                q->next = NULL;
                break;//建立链尾结点
            }
            p = p->next;
        }
        p = p->next;
        while( p != NULL ) //检索所有剩余的班级
        {
            r = k = head1; //问题：最后一个班级检索没有被处理
            while( r != NULL ) //检索班级是否相同
            {
                if( p->num / 100 == r->class_num )
                {
                    r->all_stu++;
                    if( ( p->Math ).ord_scor >= 90.0 )
                        r->excel_stu++;
                    break;
                }
                else
                {
                    k = r;
                    r = r->next;
                }
            }
            if( r == NULL ) //没有相同的班级，插入新结点
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Math ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                k->next = q;
                q->next = r;
            }
            p = p->next; //检索下一个处理的班级
        }
        bubble_sort_print( head1, len );
    }
    break;
    case 3://查询英语
    {
        p = head;
        head1 = q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
        head1->class_num = p->num / 100; //初始化头节点
        head1->all_stu = 1;
        if( ( p->English ).ord_scor >= 90.0 )
            head1->excel_stu = 1;
        else
            head1->excel_stu = 0;
        p = p->next;
        while( p->next != NULL ) //先建立两个两个首、尾结点,以便其它班级的插入
        {
            if( p->num / 100 == head1->class_num ) //相同班级
            {
                head1->all_stu++;
                if( ( p->English ).ord_scor >= 90.0 )
                    head1->excel_stu++;
            }
            else
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->English ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                head1->next = q;
                q->next = NULL;
                break;//建立链尾结点
            }
            p = p->next;
        }
        p = p->next;
        while( p != NULL ) //检索所有剩余的班级
        {
            r = k = head1; //问题：最后一个班级检索没有被处理
            while( r != NULL ) //检索班级是否相同
            {
                if( p->num / 100 == r->class_num )
                {
                    r->all_stu++;
                    if( ( p->English ).ord_scor >= 90.0 )
                        r->excel_stu++;
                    break;
                }
                else
                {
                    k = r;
                    r = r->next;
                }
            }
            if( r == NULL ) //没有相同的班级，插入新结点
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->English ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                k->next = q;
                q->next = r;
            }
            p = p->next; //检索下一个处理的班级
        }
        bubble_sort_print( head1, len );
    }
    break;
    case 4://查询物理
    {
        p = head;
        head1 = q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
        head1->class_num = p->num / 100; //初始化头节点
        head1->all_stu = 1;
        if( ( p->Physics ).ord_scor >= 90.0 )
            head1->excel_stu = 1;
        else
            head1->excel_stu = 0;
        p = p->next;
        while( p->next != NULL ) //先建立两个两个首、尾结点,以便其它班级的插入
        {
            if( p->num / 100 == head1->class_num ) //相同班级
            {
                head1->all_stu++;
                if( ( p->Physics ).ord_scor >= 90.0 )
                    head1->excel_stu++;
            }
            else
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Physics ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                head1->next = q;
                q->next = NULL;
                break;//建立链尾结点
            }
            p = p->next;
        }
        p = p->next;
        while( p != NULL ) //检索所有剩余的班级
        {
            r = k = head1; //问题：最后一个班级检索没有被处理
            while( r != NULL ) //检索班级是否相同
            {
                if( p->num / 100 == r->class_num )
                {
                    r->all_stu++;
                    if( ( p->Physics ).ord_scor >= 90.0 )
                        r->excel_stu++;
                    break;
                }
                else
                {
                    k = r;
                    r = r->next;
                }
            }
            if( r == NULL ) //没有相同的班级，插入新结点
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Physics ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                k->next = q;
                q->next = r;
            }
            p = p->next; //检索下一个处理的班级
        }
        bubble_sort_print( head1, len );
    }
    break;
    case 5://查询化学
    {
        p = head;
        head1 = q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
        head1->class_num = p->num / 100; //初始化头节点
        head1->all_stu = 1;
        if( ( p->Chem ).ord_scor >= 90.0 )
            head1->excel_stu = 1;
        else
            head1->excel_stu = 0;
        p = p->next;
        while( p->next != NULL ) //先建立两个两个首、尾结点,以便其它班级的插入
        {
            if( p->num / 100 == head1->class_num ) //相同班级
            {
                head1->all_stu++;
                if( ( p->Chem ).ord_scor >= 90.0 )
                    head1->excel_stu++;
            }
            else
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Chem ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                head1->next = q;
                q->next = NULL;
                break;//建立链尾结点
            }
            p = p->next;
        }
        p = p->next;
        while( p != NULL ) //检索所有剩余的班级
        {
            r = k = head1; //问题：最后一个班级检索没有被处理
            while( r != NULL ) //检索班级是否相同
            {
                if( p->num / 100 == r->class_num )
                {
                    r->all_stu++;
                    if( ( p->Chem ).ord_scor >= 90.0 )
                        r->excel_stu++;
                    break;
                }
                else
                {
                    k = r;
                    r = r->next;
                }
            }
            if( r == NULL ) //没有相同的班级，插入新结点
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Chem ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                k->next = q;
                q->next = r;
            }
            p = p->next; //检索下一个处理的班级
        }
        bubble_sort_print( head1, len );
    }
    break;
    case 6://查询生物
    {
        p = head;
        head1 = q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
        head1->class_num = p->num / 100; //初始化头节点
        head1->all_stu = 1;
        if( ( p->Bio ).ord_scor >= 90.0 )
            head1->excel_stu = 1;
        else
            head1->excel_stu = 0;
        p = p->next;
        while( p->next != NULL ) //先建立两个两个首、尾结点,以便其它班级的插入
        {
            if( p->num / 100 == head1->class_num ) //相同班级
            {
                head1->all_stu++;
                if( ( p->Bio ).ord_scor >= 90.0 )
                    head1->excel_stu++;
            }
            else
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Bio ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                head1->next = q;
                q->next = NULL;
                break;//建立链尾结点
            }
            p = p->next;
        }
        p = p->next;
        while( p != NULL ) //检索所有剩余的班级
        {
            r = k = head1; //问题：最后一个班级检索没有被处理
            while( r != NULL ) //检索班级是否相同
            {
                if( p->num / 100 == r->class_num )
                {
                    r->all_stu++;
                    if( ( p->Bio ).ord_scor >= 90.0 )
                        r->excel_stu++;
                    break;
                }
                else
                {
                    k = r;
                    r = r->next;
                }
            }
            if( r == NULL ) //没有相同的班级，插入新结点
            {
                q = ( struct class_excel_rate * )malloc( sizeof( struct class_excel_rate ) );
                q->class_num = p->num / 100;
                q->all_stu = 1;
                if( ( p->Bio ).ord_scor >= 90.0 )
                    q->excel_stu = 1;
                else
                    q->excel_stu = 0;
                k->next = q;
                q->next = r;
            }
            p = p->next; //检索下一个处理的班级
        }
        bubble_sort_print( head1, len );
    }
    break;
    }
}

void select_course_find( lis *head ) //选择查询课程优秀率
{
    int select, cnt = 0;
    p = head;
    while( p != NULL )
    {
        cnt++;
        p = p->next;
    }
    printf( "请输入课程代表的编号（1-语文，2-数学，3-英语，4-物理，5-化学，6-生物）：" );
    scanf( "%d", &select );
    switch( select )
    {
    case 1:
        select_class_find( head, cnt, select );
        break;
    case 2:
        select_class_find( head, cnt, select );
        break;
    case 3:
        select_class_find( head, cnt, select );
        break;
    case 4:
        select_class_find( head, cnt, select );
        break;
    case 5:
        select_class_find( head, cnt, select );
        break;
    case 6:
        select_class_find( head, cnt, select );
        break;
    default:
        printf( "输入错误！\n" );
    }
}

void output( lis *head ) //输出学生信息
{
    p = setup;
    p = head;
    printf( "学号    姓名    语文      数学      英语      物理      化学      生物\n" );
    while( p != NULL )
    {
        printf( "%d%7s%8.2f%10.2f%10.2f%10.2f%10.2f%10.2f\n", p->num, p->name, ( p->Chinese ).ord_scor, ( p->Math ).ord_scor, ( p->English ).ord_scor, ( p->Physics ).ord_scor, ( p->Chem ).ord_scor, ( p->Bio ).ord_scor );
        p = p->next;
    }
}

void print()
{
    printf( "\t\t-------学生成绩管理系统-------\n" );
    printf( "\t\t\t0、浏览学生信息\n\t\t\t1、输入学生信息\n\t\t\t2、增加学生信息\n\t\t\t3、修改学生信息\n\t\t\t4、删除学生信息\n\t\t\t5、按学号查询\n" );
    printf( "\t\t\t6、按班级查询\n\t\t\t7、按姓名查询\n\t\t\t8、按课堂名称查询\n\t\t\t9、按总分高低排序\n\t\t\t10、单科成绩排名\n\t\t\t11、查询班级优秀率\n\t\t\t12、清屏\n\t\t\t13、退出系统\n" );
    printf( "\t\t------------------------------\n" );
    printf( "\n>>请输入要实现功能前的序号:  " );
}

int main()
{
    int fun;
    lis *student;
    print();
    while( 1 )
    {
        scanf( "%d", &fun );
        switch( fun )
        {
        case 0:
            output( student );
            break;
        case 1:
            student = input();
            break;
        case 2:
            student = add( student );
            break;
        case 3:
            student = alter( student );
            break;
        case 4:
            student = delet( student );
            break;
        case 5:
        case 6:
        case 7:
        case 8:
            search( student, fun );
            break;
        case 9:
            final_score_sort( student );
            break;
        case 10:
            single_course_sort( student );
            break;
        case 11:
            select_course_find( student );
            break;
        case 12: {
            system( "cls" );
            print();
        }
        }
        if( fun == 1 )
        {
            system( "cls" );
            print();
        }
        else if( fun == 13 )
            break;
        else if( fun > 13 )
            printf( "\n\t**输入错误！\n>>请输入要实现功能前的序号: " );
        else if( fun != 12 )
            printf( "\n>>请输入要实现功能前的序号: " );
    }
    return 0;
}

/*测试数据
150901 james  100  99    94   89.9    93    95
130118 bryant 93   98    75   78.9    99.2  97.1
161226 lu     85   99    78   79      66    66.9
130821 jordon 99   100   98.1 90.6    91    89.9
150928 antony 98   97.4  91.9 89      78    79.4
161127 durant 100  98    93   82      97    80
161222 love   90   89    90   91.2    93    82.7
130156 duncan 99   98    91   82.5    89    78
160703 paul   90   91.5  98   89      87.9  80
150433 wade   93   93.4  95   91      89    80.9
161316 irving 96   89    91.8 95      91    98.8
161205 harden 89   88    93   95      96.7  99
161305 curry  89.9 92    89   46.9    39    100
160739 bosh   91.5 78    98   69.9    89    85
0
*/

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/127355.html原文链接：https://javaforall.net

赞 (0)
0 0

关于作者

全栈程序员-站长的头像

全栈程序员-站长

133.5K 文章
3 粉丝
本网站汇聚当前互联网主流语音，持续更新，欢迎关注公众号“全栈程序员社区”
上一篇 2022年4月9日 下午4:20
下一篇 2022年4月9日 下午4:20


相关推荐

  • Vue3—父子组件传值(子组件使用 emit 传值到父组件)

    Vue3—父子组件传值(子组件使用 emit 传值到父组件)

    Vue3—父子组件传值(子组件使用 emit 传值到父组件)Vue3中，子组件通过setup函数中的第一个参数值props拿到定义的组件参数进行使用。如果要向父组件传参，需要使用setup函数中的第二个参数值context（组件上下文）中的emit。例1：Tab菜单子组件创建子组件Tabs.vue<template><divclass=”Tabs”><divv-for=”(menu,index)inlistMenu”:key=”index”…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年5月17日
    135
  • redis在linux安装_安装win7系统卡在安装程序

    redis在linux安装_安装win7系统卡在安装程序

    redis在linux安装_安装win7系统卡在安装程序1、首先上官网下载Redis压缩包，地址：http://redis.io/download选择一个稳定版下载。使用工具上传压缩文件到linux系统2、通过远程管理工具，将压缩包拷贝到Linux服务器中，执行解压操作cdRedistar-zkvfredis.tar.gz3、执行make命令对Redis解压后文件进行编译cdredismake4、编译完成之…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年10月5日
    4
  • pytcharm2021激活码（最新序列号破解） idea

    pytcharm2021激活码（最新序列号破解）

    pytcharm2021激活码（最新序列号破解），https://javaforall.net/100143.html。详细ieda激活码不妨到全栈程序员必看教程网一起来了解一下吧！

    全栈程序员-站长的头像 全栈程序员-站长
    2022年3月20日
    93
  • C下WPF中实现贪吃蛇小游戏(超详细步骤附带源码)

    C下WPF中实现贪吃蛇小游戏(超详细步骤附带源码)

    C下WPF中实现贪吃蛇小游戏(超详细步骤附带源码)一 编程思想 在制作此小游戏的时候我们应该明白我们的目标是什么 然后一步步去实现 1 首先得考虑到游戏页面的布局 游戏区域以及控制游戏的区域两部分 2 在计时器下小蛇的生成 3 小蛇自身的长度 以及位置和蛇头与蛇身的区别 4 食物的随机生成 以及食物的随机位置和渐变色 5 点击游戏开始时 播放游戏背景音乐 当音乐播放完时让其音乐重新播放也就是所谓的音乐循环播放 6 控制小蛇的移动 还有按下方向键的时候改变小蛇移动的方向 7 蛇吃到食物后自身的长度和得分加一 而且被吃到的食物消失 并播放吃到食物

    全栈程序员-站长的头像 全栈程序员-站长
    2026年3月26日
    2
  • OpenClaw技术解析与2026年自动化部署全流程指南 openclaw

    OpenClaw技术解析与2026年自动化部署全流程指南

    OpenClaw技术解析与2026年自动化部署全流程指南

    全栈程序员-站长的头像 全栈程序员-站长
    2026年3月13日
    2
  • 一对兔子从出生后第三个月起每个月_兔子繁衍问题python

    一对兔子从出生后第三个月起每个月_兔子繁衍问题python

    一对兔子从出生后第三个月起每个月_兔子繁衍问题python7-6 兔子繁衍问题 (20分)一对兔子，从出生后第3个月起每个月都生一对兔子。小兔子长到第3个月后每个月又生一对兔子。假如兔子都不死，请问第1个月出生的一对兔子，至少需要繁衍到第几个月时兔子总数才可以达到N对？输入格式: 输入在一行中给出一个不超过10000的正整数N。输出格式: 在一行中输出兔子总数达到N最少需要的月数。 输入样例: 30 输出样例: 9#includ…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年8月18日
    12

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号