数据结构-学生成绩管理系统

1、问题重述：

学生信息的录入、查询、修改、排序、按学生成绩确定名次以及信息的输出。

其中学生信息包含：学号、姓名、专业、四门课、总分以及排名；

信息修改仅对四门成绩进行修改；

信息查询可以按照学号和姓名两种查询方法；

排序方法要给出四种：双向冒泡排序、希尔排序、快速排序、堆排序。

2、问题分析：采用单链表存储

3、算法分析：（具体代码在最后）

（1）、双向冒泡排序

原理：

 比较相邻两个元素的大小。如果前一个元素比后一个元素大，则两元素位置交换

对数组中所有元素的组合进行第1步的比较

奇数趟时从左向右进行比较和交换

偶数趟时从右向左进行比较和交换

当从左端开始遍历的指针与从右端开始遍历的指针相遇时，排序结束

代码：

void scoreManage::bubble_sort() {
	student* arr;//学生数组
	arr = linktoarray();//有学生链表得到学生数组
	int n = total();//链表长度
	int flag = 1;int i = 0;//flag=1有交换，flag=0无交换
	while (flag == 1)
	{
		flag = 0;
		for (int j = n - i - 1;j > i;j--)//从后往前比较
		{
			if (arr[j - 1].total_score > arr[j].total_score)
			{
				flag = 1;
				student tmp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = tmp;
			}
		}
		for (int j = i + 1;j < n - i - 1;j++)//从前往后比较
		{
			if (arr[j].total_score > arr[j + 1].total_score)
			{
				flag = 1;
				student tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}

		i++;
	}
	arrytolink(arr);//根据排序后的数组对原链表添加排序序号
}

 

（2）、希尔排序

**将待排序的表 按照间隔 切割成若干个子表，然后对这些之表进行 插入排序。
        **一般来说 第一次的间隔（divide ) 为整个排序表的一半（divide = ceil(size /2);）
       **然后对按照这些间隔划分的子表进行直接插入排序，第二次间隔又是第一次的一半（ divide = ceil(divide / 2)）
       **然后对按照这些间隔划分的子表进行直接插入排序。一直到间隔（divide ) 等于1为止,此时表内全部的数据都已是有序的。

代码：

void scoreManage::Hill_sort() {
	student* arr;
	arr = linktoarray();//链表数组
	int n = total();//链表长度
	int  j, i;
	student temp;
	int divide = ceil(n / 2);//取长度一半，取整
	for (divide;divide >= 1; divide = ceil(divide / 2)) {//对每个h分组进行插入排序，直到h==0
		for (i = divide;i < n;i++) {//单次插入排序
			if (arr[i].total_score < arr[i - divide].total_score) {
				temp = arr[i];
			//	将A[i]插入到A[i - h]，A[i - 2h]...中
				for (j = i - divide;j >= 0 && arr[j].total_score > temp.total_score;j = j - divide) {
					arr[j + divide] = arr[j];
				}
				arr[j + divide] = temp;
			}
		}
	}

	arrytolink(arr);
}

（3）、快速排序

原理：在A[1..n]中任取一个数据元素作为比较的“基准”（不妨记为X），将数据区划分为左右两个部分：A[1..i-1]和A[i+1..n]，且A[1..i-1]≤X≤A[i+1..n](1≤i≤n)，当A[1..i-1]和A[i+1..n]非空时，分别对它们进行上          述的划分过程，直至所有数据元素均已排序为止。

伪代码：

Partition(A,p,r) //p、r为数组下标

      x = A[r]   //将最后一个元素作为主元素

      i = p-1 // i指向的是比主元素小的位置，

      for  j = p  to  r-1     //从第一个元素开始到倒数第二个元素结束，比较确定主元 素的位置

          do  if  A[j] <= x

                       then  i = i+1 //如果比主元素小，则把i=i+1的位置上的元素和j位置发现小元素互换

                                exchange A[i] <-> A[j]

      exchange A[i+1]<->A[r]   //最终确定主元的位置

      return i+1   //返回主元的位置

 

end

代码：

void scoreManage::quick_sort(student* a, int low, int high) {
	if (low < high)  //判断是否满足排序条件，递归的终止条件
	{
		int i = low, j = high;   //把待排序数组元素的第一个和最后一个下标分别赋值给i,j，使用i,j进行排序；
		student x = a[low];    //第一个元素作为基元，将数组划分为大于基元以及小于基元的两部分
		while (i < j)
		{
			while (i < j && a[j].total_score >= x.total_score) j--;  //从最右侧元素开始，如果比哨兵大，那么它的位置就正确，然后判断前一个元素，直到不满足条件
			if (i < j)
			{
				a[i++] = a[j];
			}  //把不满足位次条件的那个元素值赋值给第一个元素，并把i的加1
			while (i < j && a[i].total_score <= x.total_score) i++; //换成左侧下标为i的元素开始与哨兵比较大小，比其小，那么它所处的位置就正确，然后判断后一个，直到不满足条件
			if (i < j) {
				a[j--] = a[i];
			}//把不满足位次条件的那个元素值赋值给下标为j的元素,并把j的加1
		}
		a[i] = x;   //完成一次排序，把哨兵赋值到下标为i的位置，即前面的都比它小，后面的都比它大
		quick_sort(a, low, i - 1);  //递归进行哨兵前后两部分元素排序 ， low,high的值不发生变化，i处于中间
		quick_sort(a, i + 1, high);
	}
}

（4）、堆排序

a.算法描述：堆排序是一种树形选择排序，在排序过程中，将A[1..n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。根据堆中根节点的关键           字大小，分为大根堆和小根堆。

  b.   主要是有个步骤：（1）调整堆；（2）选择、交换、调整。

代码：

/*
*构造小根堆
* */
void scoreManage::heapp(student* a, int i, int n) {
	int j = 2 * i + 1;//找到当前结点的左孩子
	student temp = a[i];//为值转化做准备
	while (j < n) {
		if (j + 1 < n && a[j].total_score < a[j + 1].total_score)  ++j;//确保与父结点交换的是最大的孩子
		if (temp.total_score > a[j].total_score) 	break;
		else {
			a[i] = a[j];
			i = j;
			j = 2 * i + 1;
		}
	}
	a[i] = temp;
}

/*
* 堆排序
*/
void scoreManage::heap_sort() {
	student* a;
	a = linktoarray();//链表数组
	int n = total();//链表长度
	for (int i = n / 2 - 1; i >= 0; i--)
		heapp(a, i, n);
	for (int i = n - 1; i >= 1; i--) {//逆序
		student t;
		t = a[0];
		a[0] = a[i];
		a[i] = t;
		heapp(a, 0, i);
	}
	arrytolink(a);
}

4、运行实例：

初始文件内容;

输入2

修改成绩

排序

排序后

保存

附属全代码：

scoreManage.h

#include <string>
#include<iostream>
using namespace std;
struct student {
	int id;//学号
	string name;//姓名
	string major;//专业
	double math_score;//高数成绩
	double english_score;//英语成绩
	double psy_score;//大物成绩
	double major_score;//专业成绩
	double total_score;//总分
	int sortid = 1;
};
struct studentNode {
	student stu;//包含学生信息
	studentNode* next;
};
class scoreManage {
public:
	studentNode* first;
public:
	scoreManage();
	~scoreManage();
	void load_file();//加载文件信息
	void save_file();//保存
	int total();//计算学生总数
	bool is_same(studentNode* bt);//判断学号是否重复的函数的声明
	void add_student(studentNode* bt, int t = 1);//添加学生
	void del_student(int id);//删除学生
	void modify_score(double score);//修改成绩
	studentNode* tool();//学生信息
	studentNode* find_student(int id);//通过学号查找学生
	studentNode* find_student(string name);//通过姓名查找
	void print_one(studentNode* bt);//输出单个学生信息
	void print();//输出所有学生信息
	void sort_print();//输出排序后的学生信息
	void bubble_sort();//双向冒泡排序
	void Hill_sort();//希尔排序
	void quick_sort(student a[], int low, int high);//快速排序
	void heap_sort();//堆排序
	student* linktoarray();//链表->数组
	void arrytolink(student* stu);
private:
	void heapp(student* a, int k, int n);//调整堆
};
void start();
void menu();

scoreManange.cpp
#include <iostream>
#include<stdio.h>
#include<fstream>
#include<conio.h>//catch() 任意键继续
#include <windows.h>//system("cls") 清屏
#pragma warning(disable:4996)
#include<iostream>
#include<fstream>
#include<iomanip>
#include<string>
#include<algorithm>
#include<sstream>
#include "scoreManage.h"
#include<string>
using namespace std;
scoreManage test;
/*
* 初始化，读取文件
*/
scoreManage::scoreManage() {
	first = NULL;
	load_file();
}
/*
* 对象调用结束
*/
scoreManage::~scoreManage() {
}
/*
* 判断学号是否重复（学号必须唯一）
*/
bool scoreManage::is_same(studentNode* bt) {
	studentNode* p = first;
	while (p)
	{
		if (p->stu.id == bt->stu.id)
		{
			return false;
		}
		p = p->next;
	}
	return true;
}
/*
* 将txt中数据读入链表中
*/
void scoreManage::load_file() {
	FILE* fp;
	studentNode* p = new studentNode;
	fp = fopen("E://c//studentScore.txt", "r");//以可读方式打开文件
	if (!fp)
	{
		printf("文件不存在\n");
		start();
		return;
	}
	//判断文件内容是否为空，通过读取，判断是否有
	ifstream ifs("E://c//studentScore.txt", ios::in);
	char ch;
	ifs >> ch;
	if (ifs.eof())
	{
		cout << "文件为空,请先添加！" << endl;
		return;
	}
	ifstream in;
	in.open("E://c//studentScore.txt");
	string sline;//每一行
	while (getline(in, sline))   //逐行读取txt文件

	{
		istringstream sin(sline);
		sin >> p->stu.id >> p->stu.name >> p->stu.major >> p->stu.math_score >> p->stu.english_score >> p->stu.psy_score >> p->stu.major_score >> p->stu.total_score >> p->stu.sortid;
		add_student(p, 0);
		p = new studentNode;
	}
}
/*
* 将一系列操作后的数据重新保存
*/
void scoreManage::save_file() {
	studentNode* p;
	p = first;
	if (p == NULL)
	{
		printf("现在没有学生信息，请先输入学生信息\n\n");
		studentNode* q = tool();
		add_student(q);
		return;
	}
	//先清空txt
	fstream file("E://c//studentScore.txt", ios::out);
	fstream in("E://c//studentScore.txt");     //打开txt
	int c = 0;
	while (p)
	{
		in << p->stu.id << setw(10) << p->stu.name << setw(10) << p->stu.major << setw(10) << p->stu.math_score << setw(10) << p->stu.english_score << setw(10) << p->stu.psy_score << setw(10) << p->stu.major_score << setw(10) << p->stu.math_score + p->stu.english_score + p->stu.psy_score + p->stu.major_score << setw(10) << p->stu.sortid;
		in << '\n';
		p = p->next;
	}
	in.close();

	cout << "保存成功" << endl;
}
/*
* 计算学生总数
*/
int scoreManage::total() {
	if (!first) {
		cout << ' 0' << endl;
		return 0;
	}
	int n = 0;
	studentNode* p = first;
	while (p->next != NULL)
	{
		n++;
		p = p->next;
	}
	//cout << "一共有" << n + 1 << "个学生." << endl;
	return n + 1;
}
/*
* 用于添加的学生信息
*/
studentNode* scoreManage::tool() {
	studentNode* p = new studentNode;
	cout << "请输入学号：" << endl;
	int id;
	cin >> id;
	p->stu.id = id;
	cout << "请输入姓名：" << endl;
	string name;
	cin >> name;
	p->stu.name = name;
	cout << "请输入专业：" << endl;
	string major;
	cin >> major;
	p->stu.major = major;
	cout << "高数成绩：" << endl;
	double score1;
	cin >> score1;
	p->stu.math_score = score1;
	cout << "英语成绩：" << endl;
	double score2;
	cin >> score2;
	p->stu.english_score = score2;
	cout << "大物成绩：" << endl;
	double score3;
	cin >> score3;
	p->stu.psy_score = score3;
	cout << "专业成绩：" << endl;
	double score4;
	cin >> score4;
	p->stu.major_score = score4;
	p->stu.total_score = score1 + score2 + score3 + score4;
	return p;
}
/*
* 添加学生信息
*/
void scoreManage::add_student(studentNode* bt, int t) {
	studentNode* p = new studentNode;
	if (first == NULL)//如果链表为空
	{
		first = bt;
		bt->next = NULL;
		return;//插入完成返回
	}
	else {
		if (is_same(bt))//判断学号是否重复
		{
			p = first;//从头结点开始找
			while (p)//p非空则一直循环
			{
				if (p->next == NULL)//找到尾节点
				{
					p->next = bt;
					bt->next = NULL;
					return;//插入完成返回
				}
				p = p->next;//找下一个节点
			}
		}
		else {
			cout << "学号重复!此学生信息添加失败" << endl;
			if (t == 0) {
				return;
			}
			if (t == 1) {
				cout << "是否重新输入：（1-yes 2-no）" << endl;
				int d;
				cin >> d;
				switch (d)
				{
				case 1:
				{studentNode* q = tool();
				add_student(q);//重新添加
				};
				default:
					break;
				}
			}
		}
	}
}
/*
* 删除某个学生信息
*/
void scoreManage::del_student(int id) {
	studentNode* pre = new studentNode;//前驱指针
	studentNode* p = first;
	pre->next = p;
	while (p)
	{
		if (p->stu.id == id)//找到
		{
			pre->next = p->next;
			p->next = NULL;
			delete p;
			cout << "删除成功" << endl;
		}
		pre->next = p;
		p = p->next;
	}
	cout << "未找到信息!" << endl;
}
/*
* 修改学生成绩，通过选择判断输入具体学科的成绩
*/
void scoreManage::modify_score(double score) {
	studentNode* p;
	cout << "查找学生的方式：（1-学号查找 2-姓名查找）" << endl;
	int chioce;
	cin >> chioce;
	switch (chioce)
	{
	case 1: {
		cout << "请输入学号：" << endl;
		int name;
		cin >> name;
		p = find_student(name);
		if (!p) {
			cout << "未找到相关信息！" << endl;
			modify_score(score);
		}
		else {
			cout << "选择要修改的学科：（1-高数 2-英语 3-大物 4-专业）" << endl;
			int c;
			cin >> c;
			switch (c) {
			case 1:
				p->stu.math_score = score;
				cout << "修改成功" << endl;
				break;
			case 2:
				p->stu.english_score = score;
				cout << "修改成功" << endl;
				break;
			case 3:
				p->stu.psy_score = score;
				cout << "修改成功" << endl;
				break;
			case 4:
				p->stu.major_score = score;
				cout << "修改成功" << endl;
				break;
			default:
				cout << "无效字符" << endl;
				modify_score(score);
				break;
			}
			p->stu.total_score = p->stu.math_score + p->stu.english_score + p->stu.psy_score + p->stu.major_score;
		}
	}
		  break;
	case 2: {
		cout << "请输入姓名：" << endl;
		string name;
		cin >> name;
		p = find_student(name);
		if (!p) {
			cout << "未找到相关信息！" << endl;
			modify_score(score);
		}
		else {
			cout << "选择要修改的学科：（1-高数 2-英语 3-大物 4-专业）" << endl;
			int c;
			cin >> c;
			switch (c) {
			case 1:
				p->stu.math_score = score;
				break;
			case 2:
				p->stu.english_score = score;
				break;
			case 3:
				p->stu.psy_score = score;
				break;
			case 4:
				p->stu.major_score = score;
				break;
			default:
				cout << "无效字符" << endl;
				modify_score(score);
				break;
			}
			p->stu.total_score = p->stu.math_score + p->stu.english_score + p->stu.psy_score + p->stu.major_score;
		}
	}
		  break;
	default:
		cout << "无效字符" << endl;
		cout << "是否重新输入：（1-yes 2-no）" << endl;
		int d;
		cin >> d;
		switch (d)
		{
		case 1:
			modify_score(score);//重新继续输入
		default:
			break;
		}

		break;
	}
}
/*
* 查找学生（通过学号）
*/
studentNode* scoreManage::find_student(int id) {
	studentNode* p = new studentNode;
	p = first;
	while (p)
	{
		if (p->stu.id == id)
		{
			return p;
		}
		p = p->next;
	}
	return NULL;
}
/*
查找学生（通过姓名）
*/
studentNode* scoreManage::find_student(string name) {
	studentNode* p = new studentNode;
	p = first;
	while (p)
	{
		if (strcmp(name.c_str(), p->stu.name.c_str()) == 0)//必须是字符数组
		{
			return p;
		}
		p = p->next;
	}
	return NULL;
}
/*
* 打印某个学生信息，主要工查找函数调用
*/
void scoreManage::print_one(studentNode* bt) {
	if (!bt) {
		cout << "未找到相关信息！" << endl;
	}
	else {
		cout << "查找成功" << endl;
		cout << "学号\t姓名\t专业\t高数成绩\t英语成绩\t大物成绩\t专业成绩\t总分成绩\t\t排名" << endl;
		cout << bt->stu.id << '\t' << bt->stu.name << '\t' << bt->stu.major << '\t' << bt->stu.math_score << "\t        " << bt->stu.english_score << "\t        " << bt->stu.psy_score << "\t        " << bt->stu.major_score << "\t          " << bt->stu.total_score << "\t        " << bt->stu.sortid << endl;
	}
}
/*
* 打印所有学生
*/
void scoreManage::print() {
	if (!first) {
		cout << "没有学生信息" << endl;
		return;
	}
	studentNode* bt;
	bt = first;
	cout << "学号\t姓名\t专业\t高数成绩\t英语成绩\t大物成绩\t专业成绩\t总成绩\t\t排名" << endl;
	while (bt) {
		cout << bt->stu.id << '\t' << bt->stu.name << '\t' << bt->stu.major << '\t' << bt->stu.math_score << "\t        " << bt->stu.english_score << "\t        " << bt->stu.psy_score << "\t         " << bt->stu.major_score << "\t        " << bt->stu.total_score << "\t        " << bt->stu.sortid << endl;
		bt = bt->next;
	}
}
void scoreManage::sort_print() {
	print();
}

/*
*/
student* scoreManage::linktoarray() {
	studentNode* p;
	p = first;
	int n = total();
	student* stu = new student[n];
	if (!first) {
		cout << "没有学生" << endl;
		return NULL;
	}
	for (int i = 0;i < n;i++) {
		stu[i] = p->stu;
		p = p->next;
	}
	return stu;
}
/*
*/
void scoreManage::arrytolink(student* stu) {
	studentNode* p;
	p = first;
	int n = total();
	for (int j = 0;j < n;j++) {
		while (p) {
			if (stu[j].id == p->stu.id) {//为链表中的sortid赋值 排序序号
				p->stu.sortid = n - j;
			}
			p = p->next;
		}
		p = first;//p指向头节点
	}
}
/*
* 双向冒泡排序
*/
void scoreManage::bubble_sort() {
	student* arr;//学生数组
	arr = linktoarray();//有学生链表得到学生数组
	int n = total();//链表长度
	int flag = 1;int i = 0;//flag=1有交换，flag=0无交换
	while (flag == 1)
	{
		flag = 0;
		for (int j = n - i - 1;j > i;j--)//从后往前比较
		{
			if (arr[j - 1].total_score > arr[j].total_score)
			{
				flag = 1;
				student tmp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = tmp;
			}
		}
		for (int j = i + 1;j < n - i - 1;j++)//从前往后比较
		{
			if (arr[j].total_score > arr[j + 1].total_score)
			{
				flag = 1;
				student tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}

		i++;
	}
	arrytolink(arr);
}
/*
* 希尔排序
* 将待排序的表 按照间隔 切割成若干个子表，然后对这些之表进行 插入排序。
*一般来说 第一次的间隔（divide ) 为整个排序表的一半（divide = ceil(size /2);）
*然后对按照这些间隔划分的子表进行直接插入排序，第二次间隔又是第一次的一半（ divide = ceil(divide / 2)）
*然后对按照这些间隔划分的子表进行直接插入排序。一直到间隔（divide ) 等于1为止,此时表内全部的数据都已是有序的。

*/
void scoreManage::Hill_sort() {
	student* arr;
	arr = linktoarray();//链表数组
	int n = total();//链表长度
	int  j, i;
	student temp;
	int divide = ceil(n / 2);//取长度一半，取整
	for (divide;divide >= 1; divide = ceil(divide / 2)) {//对每个h分组进行插入排序，直到h==0
		for (i = divide;i < n;i++) {//单次插入排序
			if (arr[i].total_score < arr[i - divide].total_score) {
				temp = arr[i];
				//	将A[i]插入到A[i - h]，A[i - 2h]...中
				for (j = i - divide;j >= 0 && arr[j].total_score > temp.total_score;j = j - divide) {
					arr[j + divide] = arr[j];
				}
				arr[j + divide] = temp;
			}
		}
	}

	arrytolink(arr);
}

/*
* 快速排序
* 通过一次排序将要排序的数据分成两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后
* 再按此方法对这两部分数据分别进行快速排序。
*
*/
void scoreManage::quick_sort(student* a, int low, int high) {
	if (low < high)  //判断是否满足排序条件，递归的终止条件
	{
		int i = low, j = high;   //把待排序数组元素的第一个和最后一个下标分别赋值给i,j，使用i,j进行排序；
		student x = a[low];    //第一个元素作为哨兵，将数组划分为大于哨兵以及小于哨兵的两部分
		while (i < j)
		{
			while (i < j && a[j].total_score >= x.total_score) j--;  //从最右侧元素开始，如果比哨兵大，那么它的位置就正确，然后判断前一个元素，直到不满足条件
			if (i < j)
			{
				a[i++] = a[j];
			}  //把不满足位次条件的那个元素值赋值给第一个元素，并把i的加1
			while (i < j && a[i].total_score <= x.total_score) i++; //换成左侧下标为i的元素开始与哨兵比较大小，比其小，那么它所处的位置就正确，然后判断后一个，直到不满足条件
			if (i < j) {
				a[j--] = a[i];
			}//把不满足位次条件的那个元素值赋值给下标为j的元素,并把j的加1
		}
		a[i] = x;   //完成一次排序，把哨兵赋值到下标为i的位置，即前面的都比它小，后面的都比它大
		quick_sort(a, low, i - 1);  //递归进行哨兵前后两部分元素排序 ， low,high的值不发生变化，i处于中间
		quick_sort(a, i + 1, high);
	}
}
/*
*构造小根堆
* */
void scoreManage::heapp(student* a, int i, int n) {
	int j = 2 * i + 1;//找到当前结点的左孩子
	student temp = a[i];//为值转化做准备
	while (j < n) {
		if (j + 1 < n && a[j].total_score < a[j + 1].total_score)  ++j;//确保与父节点交换的是最大的孩子
		if (temp.total_score > a[j].total_score) 	break;
		else {
			a[i] = a[j];
			i = j;
			j = 2 * i + 1;
		}
	}
	a[i] = temp;
}

/*
* 堆排序
*/
void scoreManage::heap_sort() {
	student* a;
	a = linktoarray();//链表数组
	int n = total();//链表长度
	for (int i = n / 2 - 1; i >= 0; i--)
		heapp(a, i, n);
	for (int i = n - 1; i >= 1; i--) {//逆序
		student t;
		t = a[0];
		a[0] = a[i];
		a[i] = t;
		heapp(a, 0, i);
	}
	arrytolink(a);
}
void menu() {
	printf("   || ☆☆☆☆☆☆☆☆请选择相应功能 ☆☆☆☆☆☆☆||\n\n");
	printf("   ||             1 添加学生成绩信息               ||\n");
	printf("   ||             2 查看所有学生成绩信息           ||\n");
	printf("   ||             3 按学号查找学生成绩信息         ||\n");
	printf("   ||             4 按姓名查找学生成绩信息         ||\n");
	printf("   ||             5 删除学生成绩信息               ||\n");
	printf("   ||             6 修改学生成绩信息               ||\n");
	printf("   ||             7 选择排序方法                   ||\n");
	printf("   ||             8 保存所有学生信息               ||\n");
	printf("   ||             9 查看学生人数                   ||\n");
	printf("   ||             10退出系统                       ||\n\n");
	printf("   ||☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆||\n");
}
/*
* 成绩管理系统
*/
void start() {
	int choose;
	menu();
	cout << "请输入选择：" << endl;;/*用户的选择*/
	cin >> choose;
	switch (choose)
	{
	case 1:
	{
		system("cls");//清屏
		studentNode* p = test.tool();
		test.add_student(p);
		cout << "按任意键继续" << endl;
		getch();
		start();
	}
	break;
	case 2:
	{
		system("cls");//清屏
		test.print();
		cout << "按任意键继续" << endl;
		getch();
		start();
	}
	break;
	case 3:
	{
		system("cls");//清屏
		cout << "请输入学号:" << endl;
		int id;
		cin >> id;
		studentNode* p = test.find_student(id);
		test.print_one(p);
		cout << "按任意键继续" << endl;
		getch();
		start();
	}
	break;
	case 4:
	{
		system("cls");//清屏
		cout << "请输入name:" << endl;
		string name;
		cin >> name;
		studentNode* p = test.find_student(name);
		test.print_one(p);
		cout << "按任意键继续" << endl;
		getch();
		start();
	}
	break;
	case 5:
	{
		system("cls");//清屏
		cout << "请输入要删除学生的学号" << endl;
		int id;
		cin >> id;
		test.del_student(id);
		cout << "按任意键继续" << endl;
		getch();
		start();
	}
	break;
	case 6:
	{
		system("cls");//清屏
		cout << "请输入修改的成绩：（先输入成绩，在选择学生）" << endl;
		double score;
		cin >> score;
		test.modify_score(score);
		cout << "按任意键继续" << endl;
		getch();
		start();
	}
	break;
	case 7:
	{
		system("cls");//清屏
		cout << "请选择要采用的排序算法：（1-双向冒泡排序 2-希尔排序 3-快速排序 4-堆排序）" << endl;
		int chioce;
		cin >> chioce;
		switch (chioce)
		{
		case 1:
			test.bubble_sort();
			cout << "排序完成" << endl;
			//	start();
			break;
		case 2:
			test.Hill_sort();
			cout << "排序完成" << endl;
			//	start();
			break;
		case 3:
		{
			student* arr;
			arr = test.linktoarray();
			int n = test.total();
			test.quick_sort(arr, 0, n - 1);

			test.arrytolink(arr);
		}
		cout << "排序完成" << endl;
		//start();
		break;
		case 4:
		{
			test.heap_sort();

			cout << "排序完成" << endl;
		}
		break;
		default:
			cout << "无效字符" << endl;
			break;
		}
		cout << "按任意键继续" << endl;
		getch();
		start();
	}
	break;
	case 8:
		system("cls");//清屏
		test.save_file();
		cout << "按任意键继续" << endl;
		getch();
		start();
		break;
	case 9:
		cout << "一共有" << test.total() << "个学生" << endl;;
		cout << "按任意键继续" << endl;
		getch();
		start();
		break;
	case 10:
		cout << "再见" << endl;
		exit(0);
		break;
	default:
		cout << "无效符号" << endl;
		start();
		break;
	}
}

Main.cpp
#include<iostream>
#include "scoreManage.h"
using namespace std;

int main() {
	start();
}