• 学生成绩管理系统数据结构单链表
2021-11-22 19:54:23

不太全面，可以作为参考看一下。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
typedef struct Students       /*学生结构体*/
{
char ID[20];
char Name[20];
float Mark1;
float Mark2;
float Mark3;
float Average;
}Student;
typedef struct Points          /*一个节点*/
{
Student date;
struct Points* next;
}Point;
void stuput(Point*H)            //输入数据
{
Point* r = H;
Point* p;
p = (Point*)malloc(sizeof(Point));
while (r->next)
r = r->next;
r->next = p;
p->next = NULL;

printf("请输入学生的ID，名字，Mark1 ,Mark2 ,Mark3 \n");
scanf("%s%s%f%f%f", p->date.ID, p->date.Name, &p->date.Mark1, &p->date.Mark2, &p->date.Mark3);
p->date.Average = (p->date.Mark1 + p->date.Mark2 + p->date.Mark3) / 3.0;
printf("成绩录入成功!\n");
}
void shu(Point* H)              //遍历链表
{
Point* p;
p = H->next;
do
{
printf("%s %s %.2f %.2f %.2f %.2f\n", p->date.ID, p->date.Name, p->date.Mark1, p->date.Mark2, p->date.Mark3, p->date.Average);
p = p->next;
} while (p != NULL);
Sleep(3000);                         //延迟3秒
}
void search(Point*H)                      //按名字查询
{
Point* p = H->next;
char mz[20];
printf("请输入你要查询的名字：\n");
scanf("%s", mz);
while (strcmp(mz, p->date.Name) != 0)
p = p->next;
printf("%s %s %.2f %.2f %.2f %.2f\n", p->date.ID, p->date.Name, p->date.Mark1, p->date.Mark2, p->date.Mark3, p->date.Average);
Sleep(2000);
}
void last(Point* H)                         //单链表排序
{
void xu(Point * low, Point * high);
Point* lt = H;
Point* h = H->next;
while (lt->next != NULL)
lt = lt->next;
xu(h, lt);
}
void xu(Point* low, Point* high)
{
if (low == high || low == NULL)
return;
Point* i, * j, * k;
float pi, change;
k = low;
i = low->next;
j = low->next;
pi = low->date.Average;
while (j)
{
if (j->date.Average < pi)
{
change = j->date.Average;
j->date.Average = i->date.Average;
i->date.Average = change;
k = i;
i = i->next;
}
j = j->next;
}
change = low->date.Average;
low->date.Average = k->date.Average;
k->date.Average = change;

xu(low, k);
xu(i, high);
}
void xiu(Point* H)                     //按名字修改
{
Point* p = H->next;
char mz[20];
int n, i;
printf("请输入你要查询的名字：\n");
scanf("%s", mz);
while (strcmp(mz, p->date.Name) != 0)
p = p->next;
printf("请输入你要修改的内容：");
scanf("%f%f%f", &p->date.Mark1, &p->date.Mark2, &p->date.Mark3);
p->date.Average = (p->date.Mark1 + p->date.Mark2 + p->date.Mark3) / 3;
printf("修改成功\n");
}
void del(Point* H)                       //删除节点
{
Point* p = H->next;
Point* o = p->next;
char mz[20];
int n, i;
printf("请输入你要删除的名字：\n");
scanf("%s", mz);
while (strcmp(mz, p->next->date.Name) != 0)
p = p->next;
p->next = p->next->next;
free(o);
printf("删除成功\n");
}
int occur(Point*& H)                     //初始化
{
H = (Point*)malloc(sizeof(Point));
H->next = NULL;
return 0;
}

void start_t(Point* H)
{
system("cls");
void start1(Point * H);
printf("1.增加学生信息         2.修改学生信息\n");
printf("3.删除学生信息         4.按姓名查询\n");
printf("5.按平均成绩排序       6.输出\n");
printf("0.退出                       \n");
int n;
scanf("%d", &n);
while (n)
{
switch (n)
{
case 1:stuput(H); break;
case 2:xiu(H); break;
case 3:del(H); break;
case 4:search(H); break;
case 5:last(H); break;
case 6:shu(H); break;
}
system("cls");
printf("1.增加学生信息         2.修改学生信息\n");
printf("3.删除学生信息         4.按姓名查询\n");
printf("5.按平均成绩排序       6.输出\n");
printf("0.退出                       \n");
scanf("%d", &n);
}
}
void start_s(Point* H)
{
system("cls");                               //清屏
void start1(Point * H);
printf("1.输入名字以查询         0.退出 \n");
int n;
scanf("%d", &n);
while (n)
{
switch (n)
{
case 1:search(H); break;
}
system("cls");
printf("1.输入名字以查询         0.退出 \n");
scanf("%d", &n);
}

}
void start1(Point* H)
{
printf("1.教师系统           2.学生系统\n");
printf("0.退出\n");
int n;
scanf("%d", &n);
while (n)
{
switch (n)
{
case 1:start_t(H); break;
case 2:start_s(H); break;
}
system("cls");
printf("1.教师系统           2.学生系统\n");
printf("0.退出\n");
scanf("%d", &n)
;
}
}
int main()
{
Point* H;
occur(H);
start1(H);

return 0;
}


更多相关内容
• 单链表实现学生成绩管理系统前言需求分析详细设计增加成绩信息删除成绩信息 前言 上篇已经讲过单链表的基本实现，这篇将以一个简单的管理系统入手。 详细讲解下如何在原来单链表的基础上实现一个简单的管理系统。 ...

前言

	上篇已经讲过单链表的基本实现，这篇将以一个简单的管理系统入手。
详细讲解下如何在原来单链表的基础上实现一个简单的管理系统。
上篇文章入口：[单链表的实现](https://blog.csdn.net/qq_39625143/article/details/121420507?spm=1001.2014.3001.5501)


需求分析

	在各位同学的C语言入门课程中，很常见的会遇到各类管理系统的题目，
其实这些题目的要求大同小异，无外乎四个操作，增删改查。而在以后的工作中，
许多后端的工程师面里的最大的要求也就是增删改查。当然后面牵扯到大数据量的处理
数据库的优化等等...
那么一个简单的学生成绩管理系统应该具备或者说基本的功能应该有，
学生成绩的录入、查询、修改、删除、以及统计，其中可能还牵扯到读写文件。
那么在已知这个的条件下，比较适合作为点链表存储的内容应该是学生信息结构体

typedef struct STUDENTINOF
{
char id[BSIZE];
char name[BSIZE];
char major[BSIZE];
int C;
int computer;
int physics;
int atomic;
int optics;
}s_info;

typedef struct STUDENTNODE
{
s_info info;
struct STUDENTNODE * next;
}s_node;


详细设计

增加成绩信息

	一般情况下，学生的学号都会是唯一的，或者也可以以姓名作为唯一，
当然这个牵扯到详细的设计。在一般情况下我们都知道，姓名可能重复，但是
在学校里学号应该是唯一的，所以我们以学生的学号作为主键，那么我们就知道，当
学号重复的时候，当前数据就不应该被插入了，于是我们有了下面两段代码

// An highlighted block
s_node * CreateNode(s_info data)//创建学生节点
{
s_node * node = (s_node*)malloc(sizeof(s_node));
node->next = NULL;
node->info = data;
return node;
}
int FindStudent(char *id)//寻找学号是否已经在链表内
{
s_node * node = h_node->next;
while (node != NULL)
{
if (strcmp(node->info.id, id) == 0)
{
return 1;
}
node = node->next;
}
return 0;
}
{
s_node * node = NULL;
if (FindStudent(info.id) == 1)return 0;
node = CreateNode(info);
node->next = h_node->next;
h_node->next = node;
return 1;
}



删除成绩信息

	删除成绩信息也就是删除单链表内，符合条件的某个节点，那么一般我们会提供
一个条件作为删除的，在这里我是以学号作为删除条件

// An highlighted block
int DeleteINode(char *id)//删除学生成绩节点
{
s_node * node = h_node;
s_node * temp = NULL;
while (node->next != NULL)
{
if (strcmp(node->next->info.id, id) == 0)
{
temp = node->next;
node->next = temp->next;
free(temp);
return 1;
}
node = node->next;
}
return 0;
}


修改成绩信息

	修改和删除类似，不过修改是不需要释放节点，只需要吧数据进行修改，所以可以先找到节点的指针，然后把修改后
的数据赋值给节点内当前数据。ps:这里有个地方要注意，结构体可以用=号进行赋值，但是如果是数组的话不可以直接
赋值，要用具体的拷贝函数。

// An highlighted block
int UpdateINode(s_info info)//更新学生成绩信息
{
s_node * node = h_node;
while (node->next != NULL)
{
if (strcmp(node->next->info.id, info.id) == 0)
{
node->next->info = info;
return 1;
}
node = node->next;
}
return 0;
}


查询学生信息和浏览学生信息

	这两个放到一起来说，其实两个功能没有本质上的区别，都是对单链表的遍历。查询顾名思义，根据某种条件
查找符合条件的学生信息进行打印。浏览则是把每一个学生成绩信息都打印出来

// An highlighted block
void SelectSocreForID(char *id)//查询学号为xx的成绩信息
{
s_node * node = h_node->next;
while (node != NULL)
{
if (strcmp(node->info.id, id) == 0)
{
printf("学号:%s\n姓名:%s\n专业:%s\nC语言:%d\n计算物理学:%d\n大学物理:%d\n原子物理:%d\n光学:%d\n", node->info.id, node->info.name, node->info.major, node->info.C, node->info.computer, node->info.physics, node->info.atomic, node->info.optics);
return;
}
node = node->next;
}
printf("未查找到对应学生信息\n");
}

void SelectSocreForName(char *name)//根据姓名查询
{
s_node * node = h_node->next;
printf("  学号\t\t    姓名  \t  专业\tC语言\t计算物理学\t大学物理\t原子物理\t光学\n");
while (node != NULL)
{
if (strcmp(node->info.name, name) == 0)
{
printf("%s\t%8s\t%6s\t%5d\t%10d\t%8d\t%8d\t%4d\n", node->info.id, node->info.name, node->info.major, node->info.C, node->info.computer, node->info.physics, node->info.atomic, node->info.optics);
}
node = node->next;
}
}

void SelectSocreForMajor(char *major)//根据专业查询
{
s_node * node = h_node->next;
printf("  学号\t\t    姓名  \t  专业\tC语言\t计算物理学\t大学物理\t原子物理\t光学\n");
while (node != NULL)
{
if (strcmp(node->info.major, major) == 0)
{
printf("%s\t%8s\t%6s\t%5d\t%10d\t%8d\t%8d\t%4d\n", node->info.id, node->info.name, node->info.major, node->info.C, node->info.computer, node->info.physics, node->info.atomic, node->info.optics);
}
node = node->next;
}
}

void SelectAllStudent()//浏览学生信息
{
s_node * node = h_node->next;
printf("  学号\t\t    姓名  \t  专业\tC语言\t计算物理学\t大学物理\t原子物理\t光学\n");
while (node != NULL)
{
printf("%s\t%8s\t%6s\t%5d\t%10d\t%8d\t%8d\t%4d\n", node->info.id, node->info.name, node->info.major, node->info.C, node->info.computer, node->info.physics, node->info.atomic, node->info.optics);
node = node->next;
}
}

void SelectSocre(char *id, int subject)//根据学号，科目 打印学生成绩信息
{
s_node * node = h_node->next;
while (node != NULL)
{
if (strcmp(node->info.id, id) == 0)
{
switch (subject)
{
case 1:
printf("C语言成绩：%d\n", node->info.C);
return;
case 2:
printf("计算物理学成绩：%d\n", node->info.computer);
return;
case 3:
printf("大学物理成绩：%d\n", node->info.physics);
return;
case 4:
printf("原子物理成绩：%d\n", node->info.atomic);
return;
case 5:
printf("光学成绩：%d\n", node->info.optics);
return;
default:
return;
}
}
node = node->next;
}
printf("未查找到成绩信息\n");
}
void SelectSocreCount(char *id)//根据学号查询总分
{
s_node * node = h_node->next;
while (node != NULL)
{
if (strcmp(node->info.id, id) == 0)
{
printf("总成绩：%d\n", node->info.C + node->info.computer + node->info.physics + node->info.atomic + node->info.optics);
}
node = node->next;
}
}



总结

	以上就是对一个完整的操作单链表的管理系统，这里略去了界面录入这一块，需要的可以到我的csdn资源里下载，
也可以留下邮箱，博主给你们发送，总而言之希望这篇博文对朋友们的单链表学习有所帮助

展开全文
• 编译环境vs2017 用单链表实现学生成绩管理系统 文件包含源代码和可执行文件 为以后算法与数据结构的同学提供帮助
• 学生成绩管理程序 (使用c，go，python语言开发) 代码及版本管理地址 gitee码云版本地址(点击跳转) 要求 本程序用于教学单位（院/系）的学生成绩管理。要求程序能够实现学生信息录入（可以实现增加、删除、修改学生的...

程序设计报告

题目

学生成绩管理程序 (使用c，go，python语言开发)

代码及版本管理地址

gitee码云版本地址(点击跳转)

要求

本程序用于教学单位（院/系）的学生成绩管理。要求程序能够实现学生信息录入（可以实现增加、删除、修改学生的基本信息）、单科学习成绩的录入；班级内单科成绩排名；成绩查询：查询某个学生的各科成绩、统计所有不及格科目超过2科的学生名单。

设计思路

按照要求设计多种功能函数，并利用主函数实现功能，添加可视化操作提示。

数据结构

利用链式线性结构体Stu数据域存储学生信息，学生姓名、班级、年级、学生各科成绩为字符串型，学生编号为整型，指针域存储下一个指针地址。

功能及函数介绍

链表操作函数
（1）尾插法
void AddItem(Stu *plist) ;//尾插添加结点：传入需要添加结点的数量和头指针，从头指针遍历到尾结点，并从尾结点开始用malloc函数添加结点，添加完后将尾结点的指针域指向NULL

（2）遍历结点
Stu *NextItem(Stu *plist) ;//传入当前结点，传出下一结点

（3）链表初始化
Stu *InitList(int num);//初始化链表：利用malloc函数创建头指针，并将头指针编号为0，将头指针指针域指向NULL，并向后添加num个结点，并返回头指针

（4）寻找结点
Stu *SearchItem(int num,Stu *phead);//寻找结点：传入头指针，返回编号为num的结点位置

功能函数
（1）输出所有学生信息
 void ShowItem(Stu *p_list,Stu *p_head);//传入指针，输出其数据域学生信息

（2） 初始化程序
void InitSys(Stu *p_head);//初始化学生系统后，管理员输入数据层

（3） 保存文件(二进制)
void SaveFile(Stu *p_head);//保存文件，用wb打开文件，并利用fwrite函数写入fwrite(1,2,3,4); 参数说明：1.要写入的数据的地址，2.一次要写多少字节，3.写多少次，4.写到哪里

（4） 学生总排名
int Sort(Stu *p_head,int n_ID,int n_subject) ;//院系总排名，传入头指针、学生编号、所要排名的数据类型，用SearchItem()函数检索该编号数据地址，并从头遍历链表到NULL，对每一个结点该数据值进行检索，遇到比被排序结点数值大时sum+1

（5）学生所在班级排名
 int ClassSort(Stu *p_head,int n_ID,int n_subject) ;//班级排名，传入头指针、学生编号、所要排名的数据类型，同（4）类似，只是判断了班级是否相等，利用了strcmp()库函数，包含了<string.h>头文件

（6）查找学生
 void Search(Stu *p_head,char *name);  //搜索学生信息，传入头指针，传入学生姓名，遍历链表，找到该学生（考虑了重名情况）

（7）删除学生信息
 void Del(Stu *p_head,int n_ID); //删除表，传入头指针，传入删除学生编号。用free（）释放内存，包含头文件<stdlib>,并将前后结点相连，利用了SearchItem()函数找到3个结点地址

（8）将字符串转为double型
 double Strtodouble(char *str) ;//传入0-100的字符串返回double型函数，若传入其他字符串，则返回-1。主要用于符合成绩逻辑，利用了atof()函数，包含头文件<stdlib>

（9）添加学生
 void AddList(Stu *p_head) ;//尾部添加新同学

（10）修改学生信息
void Change(Stu *p_head);//修改学生信息，利用SearchItem（）函数

（11）统计所有不及格科目超过2科的学生名单
void NoPass(Stu *p_head);//传入头指针，输出所有不及格科目超过2科的学生名单，从头开始遍历判断

（12）单科学习成绩的录入
void InputScore(Stu *start , Stu *end , Stu *p_head ,char *subject);//单科学习成绩录入，传入开始录入位置和结束录入位置，传入头指针 ,传入需要录入的学科

（13）保存文件(txt)
void Fprint(Stu *p_head);//将数据导出到当前路径下的StudentInformation.txt，导出为txt便于使用者阅读

（14）输出单个学生信息
void ShowItem(Stu *p_list,Stu *p_head) ;//传入结点地址，输出其数据域学生信息

（15）班级内单科成绩排名
void ClassSortOutput(Stu *p_head,char *str_class,int subject);//传入头指针，传入班级，传入学科 利用了桶排序思想

（16）插入学生
void Insert(Stu *p_head) ;//在中间插入一个表，找到前后结点，free()并将前中后结点关联，并将后续结点编号加一


遇到的问题和异常处理方法

（1）对输入int型变量的控制:
if(scanf("%d",&num)!=1)
{
printf("提示：你没有输入正确值，请重新输入:");
fflush(stdin);//while(getchar()!='\n');
}


能解决输入非int型变量时，程序崩溃问题

（2）对输入字符串的问题：

利用gets()函数输入，可以读入空格，防止缓冲区同时读入多个数据。

（3）
fflush(stdin);


读入int型等变量时会将换行符读入，利用这个函数可以将缓冲区换行符清除。Stdin指缓冲区

（4）对成绩判断问题:
while(Strtodouble(p_new->m_nMath) == -1)
{
printf("提示:您的输入有问题(成绩为0-100的整数),请重新输入:");
gets(p_new->m_nMath);
}


利用Strtodouble函数对成绩输入判断，如果错误则重新输入

（5）对指针的判断：

遇到指针为NULL时，设置返回值，防止异常

联系方式

QQ773323518

展开全文
• //以单链表作为存储结构，设计和实现课程成绩管理的完整程序。 //程序包括如下功能。 //1.建立学生成绩表，包含学生的学号、姓名和成绩。 //2.可以显示所有学生成绩。 //3.可以计算学生的总数。 //4.可以按学号和...
• 数据结构课设，才用单链表结构，实现学生成绩管理，包含课程设计报告

1、链表

1.1链表的基本介绍

• 链表是以节点的方式来存储，是链式存储，从图中发现，链表的各个节点不一定是连续存储
• 每个节点包含data域：存储数据，next域：指向下一个节点
• 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

基本概念：链表的每个元素称为一个节点，每个节点都可以存储在内存中的不同的位置，为了表示每个元素与后继元素的逻辑关系，以便构成“一个节点链着一个节点”的链式存储结构，除了存储元素本身的信息外，还要存储其直接后继信息，因此，每个节点都包含两个部分，第一部分称为链表的数据区域，用于存储元素本身的数据信息，这里用data表示，它不局限于一个成员数据，也可是多个成员数据，第二部分是一个结构体指针，称为链表的指针域，用于存储其直接后继的节点信息，这里用next表示，next的值实际上就是下一个节点的地址，当前节点为末节点时，next的值设为空指针

1.2链表和数组的比较

数组：数组（包括结构体数组）的实质是一种线性表的顺序表示方式，它的优点是使用直观，便于快速、随机地存取线性表中的任一元素，但缺点是对其进行 插入和删除操作时需要移动大量的数组元素，同时由于数组属于静态内存分配，定义数组时必须指定数组的长度，程序一旦运行，其长度就不能再改变，实际使用个数不能超过数组元素最大长度的限制，否则就会发生下标越界的错误，低于最大长度时又会造成系统资源的浪费，因此空间效率差。

链表：链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的，且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作。链表的特性，使其在某些操作上比数组更加高效。例如当进行插入和删除操作时，链表操作的时间复杂度仅为O(1)。另外，因为链表在内存中不是连续存储的，所以可以充分利用内存中的碎片空间。除此之外，链表还是很多算法的基础，最常见的哈希表就是基于链表来实现的。

2、单向链表的具体实现

本节将具体介绍单向链表（带头结点）的结构和各种操作的具体实现

2.2单链表的应用实例（单链表实现学生成绩管理系统）

为了方便对链表各项操作的理解，把链表应用到具体的实例中：用带头节点的单链表实现学生成绩管理系统。对学生的成绩信息实现增删改查的操作，具体实现目标如下：

1. 添加学生成绩信息
2. 根据学号将学生信息插入到指定位置
3. 显示所有学生的信息
4. 删除指定学生成绩信息
5. 修改指定学生成绩信息
6. 查询当前链表中有多少为同学
7. 查询指定分数的学生个数，并输出查询的学生信息
8. 退出程序

package com.zhukun.LinkList;

import java.util.Scanner;

{
public int stuno;//学生学号
public String name;//学生姓名
public int score;//学生分数
//构造器
public StudentLinkNode(int stuno,String name,int score) {
this.stuno = stuno;
this.name = name;
this.score = score;
}
public void setInfo()
{
Scanner scanner = new Scanner(System.in);
System.out.print("学号：");
this.stuno = scanner.nextInt();
System.out.print("姓名：");
this.name = scanner.next();
System.out.print("分数：");
this.score = scanner.nextInt();
}
//为了显示方法，重写toString方法
public String toString() {
return "学号:    "+stuno+"    "+"姓名"+name+"    "+"分数"+score;
}
}
//先初始化一个头节点，头节点不要动，不存放具体的数据

//添加结点到单向链表
//当不考虑编号顺序时
//1、找到当前链表的最后结节点
//2、将最后这个节点的next 指向 新的结点
{
while(true) {
//找到链表的最后的节点
if(temp.next == null)
{
//找到
break;
}
//如果遍历的当前结点不是尾结点，将temp节点向后移动
temp = temp.next;
}
//当退出while循环时，表示temp就指向了链表的尾节点
temp.next = stuNode;
}

//第二种添加方式，在添加学生时根据学号将学生插入到指定位置
{
//因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为是单链表，我们找的temp是位于添加位置的前一个节点，否则插入不了
boolean flag = false;//flag标志添加的学号是否存在，默认为false
while(true)
{
if(temp.next == null) //说明temp已经在链表的最后
{
break;
}
if(temp.next.stuno > stuNode.stuno)//位置找到，就在temp的后面插入
{
break;
}
else if(temp.next.stuno == stuNode.stuno)//说明想要添加的
{
flag = true;//说明编号存在
break;
}
temp = temp.next;//后移
}
//判断flag的值
if(flag)
{   //不能添加，说明编号存在
System.out.println("准备添加的学生的学号:"+stuNode.stuno+"已经存在不能添加了");
}else {
//插入到链表中，temp的后面
stuNode.next = temp.next;
temp.next = stuNode;
}
}
//遍历链表
public void showlist() {
//判断链表是否为空
{
System.out.println("链表为空");
return;
}
//因为头节点，不能动，因此我们需要一个辅助变量来遍历
while(true)
{
//判断是否到链表最后
if(temp == null)
{
break;
}
//输出节点的信息
System.out.println();
//将temp后移
temp = temp.next;
}
}
//返回链表中共有多少个学生的信息
public int len()
{
int count=0;
//判断链表是否为空
{
System.out.println("链表为空");
return 0;
}
//因为头节点，不能动，因此我们需要一个辅助变量来遍历
while(true)
{
//判断是否到链表最后
if(temp == null)
{
break;
}
//输出节点的信息
count++;
//将temp后移
temp = temp.next;
}
return count;

}
//删除结点：根据学生学号删除指定学生节点
//2、说明我们在比较时，是temp.next.stuno和需要删除的节点的stuno比较
public void del(int stuno)
{
boolean flag =false;//标志是否找到待删除的节点
while(true)
{
if(temp.next == null)
{
break;//已经到链表的最后
}
if(temp.next.stuno == stuno)
{
//找到待删除的节点的前一个节点temp
flag = true;
break;
}
temp = temp.next;//temp后移，遍历
}
//判断flag
if(flag)
{//找到
//可以删除
temp.next = temp.next.next;
}else {
System.out.println("学号"+stuno+"的学生不存在");
}
}

//修改节点信息，根据stuno 编号来修改
{
//判断是否为空
{
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据stuno编号
//定义一个辅助变量
boolean flag =false;//表示是否找到该节点
while(true)
{
if(temp == null)
{
break;//已经遍历完链表
}
if(temp.stuno == stuNode.stuno)//找到
{
flag = true;
break;
}
temp = temp.next;
}
//根据flag判断是否找到要修改的节点
if(flag) {
temp.name = stuNode.name;
temp.score = stuNode.score;
}else {
System.out.println("没有找到学号为"+stuNode.stuno+"的学生");
}
}
//查询指定分数的学生个数，并输出查询的学生信息
public void getbyScore(int score)
{
int count=0;
System.out.println("分数为"+score+"的学生有：");
while(temp != null)
{
if(temp.score == score)
{
count++;
System.out.println("学号："+temp.stuno+"姓名："+temp.name);
}
temp = temp.next;
}
System.out.println("共上面"+count+"个");
}
}
public static void main(String[] args)
{
int n;//接收用户输入
Scanner scanner = new Scanner(System.in);
boolean loop = true;
//输出一个菜单
while(loop)
{
System.out.println("|-----欢迎来到学生成绩管理系统-----|");
System.out.println("1、添加学生成绩信息");
System.out.println("2、根据学号将学生信息插入到指定位置");
System.out.println("3、显示所有学生的信息");
System.out.println("4、删除指定学生成绩信息");
System.out.println("5、修改指定学生成绩信息");
System.out.println("6、查询当前链表中有多少为同学");
System.out.println("7、查询指定分数的学生个数，并输出查询的学生信息");
System.out.println("8、退出程序");
System.out.println("请输入你的选择:");
n = scanner.nextInt();
switch(n)
{
case 1:
System.out.println("请输入学生信息");
s1.setInfo();
break;
case 2:
System.out.println("请输入学生信息");
s2.setInfo();
break;
case 3:
list.showlist();
break;
case 4:
System.out.print("请输入你要删除的学生学号");
int stuno = scanner.nextInt();
list.del(stuno);
System.out.println("删除成功");
break;
case 5:
System.out.println("请输入你要修改的学生的学号：");
int sno = scanner.nextInt();
System.out.println("请输入修改后的姓名为：");
String  sname = scanner.next();
System.out.println("请输入修改后的分数为：");
int sco = scanner.nextInt();
list.update(s3);
System.out.println("修改成功");
break;
case 6:
int num = list.len();
System.out.println("当前链表中共记录了"+num+"位学生成绩信息");
break;
case 7:
System.out.println("请输入你要查询的分数:");
int sco2 = scanner.nextInt();
list.getbyScore(sco2);
break;
case 8:
scanner.close();
loop = false;
break;
}
}
}

}

展开全文
• 运用数据结构单链表实现对学生成绩的增删改查，录入学生成绩时运用到了C语言文件的操作，本程序介绍了两种链表组织方式头插法和尾查法。
• 数据结构—单链表实现学生信息管理系统

万次阅读 多人点赞 2019-06-19 13:50:22
printf("链表结构如下:\n"); while (p) { printf("%s %s %d %.2f", p->data.name, p->data.sno, p->data.age, p->data.score); printf("\n"); p = p->next; } } //插入操作 int ListInsert(LinkList &L...
• 学生成绩管理系统: 问题描述：已知某学生成绩表中现有N位同学的成绩（要求各人数据不同），如： 学号 姓名 成绩 01101 李平 75 01202 王露 70 01205 张强 85 01118 曹雨 90 …… …… …… 现需要删除已转学的某位...
• 数据结构-学生成绩管理系统

千次阅读 2021-02-27 19:21:17
学生信息的录入、查询、修改、排序、按学生成绩确定名次以及信息的输出。 其中学生信息包含：学号、姓名、专业、四门课、总分以及排名； 信息修改仅对四门成绩进行修改； 信息查询可以按照学号和姓名两种查询方法...
• 单链表实现学生成绩管理系统的增删改查

万次阅读 多人点赞 2018-06-04 22:55:35
写在前面：这个代码除了实现基本的数据增删改查外，还对数据进行了按学号排序输入，输出到文档中！同时对界面实现了优化！对数据插入方法使用插入排序！以及人数的统计，多种查询方式等！代码是很久之前写的，当时...
• 单链表法解决的一个学生管理系统，氪了很多时间在上面，边写编注释，建议学完新课的同学可以拿这份代码进行巩固加深理解，复习基础的同学也可以看看，结合项目复习效果会比较好
• 单链表|学生成绩管理系统（大作业）

千次阅读 多人点赞 2020-04-21 13:59:11
• 学生成绩管理系统是一个教育单位不可缺少的部分,它的内容对于学校的决策者和管理者来说都至关重要.本论文叙述到的学生成绩管理系统是用IIS+ASP网页编程+ACCESS数据库+SQL查询语言实现的.重点介绍了学生成绩管理系统...
• 学生成绩管理系统课程设计报告全文，.doc格式
• 学生信息管理系统（C语言 单链表实现） 【学生管理系统2.0】 ★————————————————————————————————————————★ | 1. 信息录入 2. 成绩录入 3. 信息查询 | | 4.
• 这是一个记录贴，记录一下我在b站学习数据结构课程的作业和一些...首先是第一个作业：用单链表完成一个学生管理系统 头文件： node.h #pragma once //#include <iostream> //using namespace std; #ifndef NODE_H
• printf("链表结构如下:\n"); while(p){ printf("%s %s %d %.2f",p->data.name,p->data.sno,p->data.age,p->data.score); printf("\n"); p=p->next; } } //插入操作 int ListInsert(LinkList &L,int location,...
• 学生成绩管理系统 数据结构 可实现查询、添加等
• 数据结构课程设计---学生成绩管理系统

千次阅读 多人点赞 2020-12-10 22:27:54
6.查找学生成绩（按照学号） 7.打印学生成绩单 C语言代码 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<malloc.h> #include<stdlib.h> #include<string.h> s..
• 数据结构课程设计报告_学生成绩管理系统西北工业大学数据结构课程设计报告: 学生成绩管理系统系(院): 理学 院专 业: 信息与计算科学班 级:姓 名: 。。。。。 学 号: 2010302676指导教师: 佘红伟学年学期: 2011 ~ ...
• C++数据结构 线性表的链式存储结构应用 简单的学生成绩管理系统 # include # include # include # include # include "stdlib.h" using namespace std ; struct Node { int num ; ...
• 数据结构课程设计---学生成绩管理系统
• 2.学生成绩应包含4科成绩和总成绩（C语言、数据结构、高数、英语） 3.建立学生成绩单并保存到文件中（直接从控制台获取） 4.打印学生成绩单 5.按学号或者姓名查找学生成绩单 6.按总成绩进行排序，并保存到新的...
• 利用单链表结构实现学生成绩动态管理，了解数据库管理的基本功能，掌握C语言中的结构体、指针、函数、（系统函数、自定义函数）、文件操作等知识，这是一个C语言知识的综合应用。其中一些难点有：指针变量做函数参数...
• 刚学到单链表，结合之前用Java实现学生信息管理系统的经验用单链表实现了一遍。 由于是小白，所以代码写得很基础，大佬轻喷（ 另外，我发誓以后再也不做学生信息管理系统了。。太无聊了 #include<stdio.h> #...
• 数据结构创建一个学生成绩管理系统，里面包含文档。

...