C语言数据结构实训——竞赛系统

这段代码是一个菜单式的程序，根据用户输入的选项执行相应的操作。下面是代码执行的大致流程：

1. 初始化变量y为1，并调用Read()函数。
2. 进入while循环，循环条件为y不等于0。
3. 调用list()函数显示菜单，并读取用户输入的选项存入变量x。
4. 根据用户输入的选项x执行对应的操作：
   • 如果x等于1，调用Insert()函数。
   • 如果x等于2，调用Delete()函数。
   • 如果x等于3，调用Exchange()函数。
   • 如果x等于4，需要创建一个空的二叉排序树root，然后循环遍历数组teams，调用insertBST()函数将每个团队插入二叉排序树root。接着，要求用户输入要查找的参赛队编号，然后调用Sreachnum()函数按照编号在二叉排序树中查找相应的节点，并输出节点的相关信息。此外，还会计算ASL（平均查找长度）。
   • 如果x等于5，要求用户输入要查找的参赛学校，然后调用Searchsch()函数按照参赛学校查找对应的参赛队伍，并输出相关信息。
   • 如果x等于6，调用Call()函数，实现一个叫号系统。
   • 如果x等于7，初始化一个包含11个景点的数组view，并使用邻接矩阵adj表示景点之间的距离。然后，要求用户输入起点v和终点v1，调用guidance()函数使用Dijkstra算法计算最短路径，并使用path数组保存路径信息。最后，输出最短路径的长度和路径。
5. 提示用户是否继续操作，读取用户的选择存入变量y。
6. 如果用户选择继续（y为1），回到第2步继续执行。
7. 如果用户选择结束（y为0），程序结束。

需要注意的是，该代码中使用的一些函数如Read()、list()、Insert()、Delete()、Exchange()、insertBST()、Sreachnum()、countASL()、Searchsch()、Call()、guidance()等在代码中没有给出，你可以自行实现这些函数以适应程序的需求。另外，还需要注意变量和函数的作用域问题，确保变量能在正确的位置被访问到。

#include<iostream>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include<string>
#include<sstream>
#include<fstream>
int const MaxSize = 11;	//最大顶点数
int const M = 9999;		//最大权值
int const Max = 500;
double ASL=0;		//平均查找长度
using namespace std;
 struct Team {
	 //参赛作品编号
	int number;
	//参赛作品名称
	string offering;
	//参赛学校
	string school;
	//赛事类别
	string category;
	//参赛者
	string name;
	//指导老师
	string teacher;
	//答辩时间
	int time;
}teams[Max];
Team s[Max],s1[Max];		//用一个数组存储查找出来的参赛队伍
struct BTree {
	//关键字值
	int number;
	//存储队伍基本信息
	Team* t;
	//结点的左右孩子指针
	BTree* lchild, * rchild;
};
struct View {
	//读取文件
	int id;				
	//景点名称
	string name;		
	//景点介绍
	string introduction;
}view[MaxSize];
int Count = 0;		//有多少个队伍
void Del_space(string& s) {    //去除字符串中的空格
	int index = 0;
	if (!s.empty()) {
	while ((index = s.find('\t', index)) != string::npos) { 
			s.erase(index, 1);
		}
	}
}
//读取文件
void Read() {
	ifstream file("team.txt");
	if (!file){
		cout << "打开文件失败" << endl;
	}
	string line;
	while (getline(file, line)) 
	{
		Team t;
		string s;
		Del_space(line);				//去除该行空格
		stringstream ss(line);
		//getline(ss, s, '#'); 			//实现字符串的输入，初始化ss
		getline(ss >> std::ws, s, '#');    //去除 cin 输入前面的空格，可以使用 std::ws 函数 
		getline(ss >> std::ws, t.offering, '#');
		getline(ss >> std::ws, t.school, '#');
		getline(ss >> std::ws, t.category, '#');
		getline(ss >> std::ws, t.name, '#');
		getline(ss >> std::ws, t.teacher, '#');
		t.number = atoi(s.c_str());	//将编号转化为整形,c_str()返回当前字符串的首字符地址,atoi (表示 ascii to integer)是把字符串转换成整型数的一个函数
		teams[Count] = t;
		Count++;
	}

	for (int i = 0; i < Count; i++)
		cout << "参赛队编号:" << teams[i].number 
		<< "参赛作品名称:" << teams[i].offering 
		<< "参赛学校:" << teams[i].school 
		<< "赛事类别:" << teams[i].category 
		<< "参赛者:" << teams[i].name 
		<< "指导老师:" << teams[i].teacher << endl;
	file.close();
	cout << "总共有 " << Count << " 个队伍" << endl;
}
//插入队伍
void Insert() {
	Team a;
	cout << "请输入添加队伍编号:";
	cin >> a.number;
	cout << "请输入添加队伍的作品名称：";
	cin >> a.offering;
	cout << "请输入添加队伍学校:";
	cin >> a.school;
	cout << "请输入添加队伍的赛事类别:";
	cin >> a.category;
	cout << "请输入添加参赛者:";
	cin >> a.name;
	cout << "请输入添加队伍指导老师:";
	cin >> a.teacher;
	teams[Count] = a;
	cout << "添加成功" << '\n';
	cout << "参赛队编号:" << teams[Count].number << "参赛作品名称:" << teams[Count].offering 
		<< "参赛学校:" << teams[Count].school << "赛事类别:" << teams[Count].category 
		<< "参赛者:" << teams[Count].name << "指导老师:" << teams[Count].teacher << endl;
	Count++;
 
}
//删除队伍
void Delete(){
	int num;
	cout << "请输入要删除的队伍编号：" << endl;
	cin >> num;
	for(int i=0;i<Count;i++){
		if (teams[i].number == num){
			cout << "删除队伍信息：" << endl;
			cout << "参赛队编号：" << teams[i].number << '\t' << "参赛作品名称：" << teams[i].offering<< '\t' 
				<< "参赛学校：" << teams[i].school << '\t' << "赛事类别：" << teams[i].category << '\t' 
				<< "参赛者：" << teams[i].name << '\t' << "指导老师：" << teams[i].teacher << endl;
			for (int j = i; j < Count; j++) {
				teams[j] = teams[j + 1];
		}
			Count--;
			cout << "删除成功" << endl;
			return;
		}
	}
	 	cout << "不存在此队伍" << endl;
}
//更改队伍信息
void Exchange() {
	int num;
	cout << "输入你要修改那个队伍的信息（输入编号）：";
	cin >> num;
	for (int i = 0; i < Count; i++) {
		if (teams[i].number == num) {
			string s1,s2,s3,s4,s5;
			cout << "请输入更改后参赛作品名称：";
			cin >> s1;
			teams[i].offering = s1;
			cout << "请输入更改后队伍学校：";
			cin >> s2;
			teams[i].school = s2;
			cout << "请输入更改后的队伍的赛事类别：";
			cin >> s3;
			teams[i].category = s3;
			cout << "请输入更改后参赛者：";
			cin >> s4;
			teams[i].name = s4;
			cout << "请输入更改后队伍指导老师：";
			cin >> s5;
			teams[i].teacher = s5;
			break;
		}
	}
	cout << "修改成功" << endl;
}
//二叉树插入结点
BTree* insertBST(BTree* root, Team* team) {
	if (root == NULL) {	//当根结点为空时
		BTree* root1 = new BTree();
		root1->number = team->number;
		root1->t = team;
		root1->lchild = NULL;
		root1->rchild = NULL;
		return root1;
	}
	if (root->number < team->number) {		//当根结点的大小小于插入结点的大小
		root->rchild = insertBST(root->rchild, team);
	}
	else if (root->number > team->number){	
		root->lchild = insertBST(root->lchild, team);
	}
	return root;
}
//按编号搜索
BTree* Sreachnum(BTree* root, int number,int depth) {
	
	if (root == NULL)return NULL;
	if (root->number == number) {
		return root;
	}
	if (root->number < number) {
		return Sreachnum(root->rchild, number,depth+1);
	}
	else return Sreachnum(root->lchild, number,depth+1);
	if (root->number != number)return NULL;
}
//返回编号的深度，用来计算ASL
int countASL(BTree* root, int number, int depth) {
	if (root == NULL)return 0;
	if (root->number == number) {
		return depth;
	}
	if (root->number < number) {
		return countASL(root->rchild, number, depth + 1);
	}
	else return countASL(root->lchild, number, depth + 1);
	if (root->number != number)return 0;
}
//将相邻两个归并段合并成一个有序段的算法
void merge(int low, int mid, int high){
	int i = low, j = mid + 1, k = low;
	while (i <= mid && j <= high){
		if (s[i].number < s[j].number)
			s1[k++] = s[i++];
		else
			s1[k++] = s[j++];
	}
	while (i <= mid)
		s1[k++] = s[i++];
	while (j <= high)
		s1[k++] = s[j++];
	for (int i = low; i <= high; i++)
		s[i] = s1[i];
}
//归并排序算法总体部分
void mergesort(int x, int y){
	if (x >= y) return;
	int mid = (x + y) / 2;
	mergesort(x, mid);
	mergesort(mid + 1, y);
	merge(x, mid, y);
}
//按学校搜索
void Searchsch(string school) {	
	int j = 0;
	for (int i = 0; i < Max; i++) {
		if (teams[i].school == school) {
			s[j] = teams[i];
			j++;
		}
	}
	//归并排序
	mergesort(0, j-1);
	for (int i = 0; i < j; i++)
		cout << s[i].number <<'\t'<<s[i].offering <<'\t' << s[i].category <<'\t' << s[i].name <<'\t' << s[i].teacher <<'\n';
}
void Call() {
    //存放所有的参赛类型
    string type[4] = {"A", "B", "C", "D"};

    //存放决赛室名称
    string room[4] = {"A", "B", "C", "D"};

    //定义四个决赛室存放队伍的数组
    Team t[4][100];

    //自定义四种类型，将队伍分成四组
    for (int i = 0; i < 4; i++) {
        int k = 0;
        for (int j = 0; j < Count; j++) {
            if (type[i] == teams[j].category) {
                t[i][k] = teams[j];
                k++;
            }
        }
    }

    //模拟决赛室内叫号系统
    srand((unsigned int)time(NULL));
    for (int i = 0; i < 4; i++) {
        int hour = 8;
        int minute = 0;
        cout << "决赛室：" << room[i] << '\n';
        int j = 0;
        while (t[i][j].category != "") {
            t[i][j].time = rand() % (10 - 5 + 1) + 5;
            if (minute > 60) {
                hour++;
                minute -= 60;
            }
            cout << hour << ":" << minute << '\t' << t[i][j].offering << '\n';
            minute += t[i][j].time;
            j++;
        }
    }
}
void guidance(int a[][MaxSize],int dist[],int v,int path[]) {		//导航系统
	int k;
	int used[MaxSize];		//判断顶点是否被访问过
	for (int i = 0; i < MaxSize; i++) {
		if (i == v)used[v] = 1;
		else	used[i] = 0;		//初始化顶点的used都为0
	}
	for (int i = 0; i < MaxSize; i++) {		//初始化dist
		if (i == v)dist[i] = 0;				//v到自身的长度为0
		else
			dist[i] = a[v][i];			//将邻接矩阵中，v到各点的距离存放进去
		if (dist[i] < M)path[i] = v;	//当v到各地的距离不是oo时，将各点的前驱直接记成v
		else path[i] = -1;				//否则，记成-1
	}
	for (int i = 1; i < MaxSize; i++) {
		int min;
		min = 9999;
		for (int j = 0; j < MaxSize; j++) {
			if (j == v)continue;
			if (!used[j] && min > dist[j]) {		//当顶点未被访问且小于min时，将最短路径赋给min，并保存该顶点下标
				min = dist[j];
				k = j;
			}
		}
		used[k] = 1;		//将该顶点标为已被访问
		for (int j = 0; j < MaxSize; j++) {
			if (j == v)continue;
			if ((dist[k] + a[k][j]) < dist[j] && !used[j]) {		//当v到某个顶点的距离大于通过上述顶点中转到该点的距离时，修改dist值
				dist[j] = dist[k] + a[k][j];
				path[j] = k;		//将k设为j的前驱
			}
		}
	}
}
void find(int path[],int v,int v1) {	//输出路径
	int s;
	if (path[v1] == v) {		//当v1的前驱是v时，输出v
		cout << v;
	}
	else {			//当v1的前驱不是v时，递归调用，查找v的后继
		s = path[v1];	
		find(path,v,s); }
	cout << "->" << v1;
	return;
}
//目录
void list() {
	cout << "学生竞赛系统1.0" << '\n';
	cout << "请输入您的选择：（功能前的数字）" << '\n';
	cout << "1.添加队伍" << '\n';
	cout << "2.删除队伍" << '\n';
	cout << "3.修改队伍信息" << '\n';
	cout << "4.查找队伍" << '\n';
	cout << "5.按参赛学校查询参赛团队" << '\n';
	cout << "6.决赛叫号系统" << '\n';
	cout << "7.校园导航系统" << '\n';
}
int main() {
	int y = 1;
	Read();
	while (y != 0) {
		list();
		int x;
		cin >> x;
		if(x==1)Insert();
		if(x==2)Delete();
		if(x==3)Exchange();
		BTree* root = NULL;
		//创建二叉排序树
		for (int i = 0; i < Max; i++) {
			root = insertBST(root, &teams[i]);
		}
		if (x == 4) {
			cout << "输入要查找的参赛队编号：";
			int number1;
			cin >> number1;
			BTree* s = new BTree();
			s = Sreachnum(root, number1, 1);			//按编号查找
			if (s != NULL) {
				cout << "参赛作品名称：" << s->t->offering << '\t' << "参赛学校：" << s->t->school
					<< '\t' << "赛事类型：" << s->t->category << '\t' << "参赛者："
					<< s->t->name << '\t' << "指导老师：" << s->t->teacher << endl;
 
				double s1 = 0;
				cout << "ASL=(";
				for (int i = 0; i < Count; i++) {
					int s2;
					s2 = countASL(root, teams[i].number, 1);
					s1 += s2;
					if (i == Count - 1)cout << s2 << ")*1/" << Count << " = ";
					else cout << s2 << "+";
				}
				ASL = s1 / Count;
				cout << ASL << '\n';
			}
			else cout << "查找失败！" << '\n';
		}
		if (x == 5) {
			cout << "输出要查找的参赛学校：";
			string Sea_school;
			cin >> Sea_school;
			Searchsch(Sea_school);				//按参赛学校查找参赛团队
		}
		if (x == 6) {
			cout << "叫号系统" << '\n';
			Call();						//叫号系统
		}
		if (x == 7) {
			cout << "校园导游系统" << '\n';
			for (int i = 0; i < 11; i++) {
				view[i].id = i;
			}
			view[0].name = "西区宿舍";
			view[0].introduction = "学生公寓区，有许多宿舍楼，是学生们休息、娱乐的地方,属于新建的宿舍楼，位于信阳农林学院西边，宿舍有空调、独立卫生间，二十四小时热水。";
			view[1].name = "学子食堂";
			view[1].introduction = "位于馨苑后边，有教工餐厅，有三层楼，菜品丰富、多样";
			view[2].name = "操场";
			view[2].introduction = "含有足球场，篮球场，排球场等。学生可以在这里踢足球、健身以及举办各种活动";
			view[3].name = "文体中心";
			view[3].introduction = "学校一餐三楼，可以举办晚会";
			view[4].name = "一号学楼";
			view[4].introduction = "公共教学大楼一号楼，是学生们上课学习的地方";
			view[5].name = "双创中心大楼";
			view[5].introduction = "信阳农林学院创新创业大楼，在行政楼对面";
			view[6].name = "图书馆";
			view[6].introduction = "是学校标志性建筑，图文咨讯中心，可以在这里自主学习，含有智能借还书系统";
			view[7].name = "新食堂";
			view[7].introduction = "学校新建的餐厅，位于三号教学楼旁边，菜品丰富、多样";
			view[8].name = "信息工程学院";
			view[8].introduction = "是计算机学院老师办公的地方，计算机专业的学生在这里进行实验和项目开发";
			view[9].name = "行政楼";
			view[9].introduction = "行政办公大楼，用于日常办公";
			view[10].name = "楚韵湖";
			view[10].introduction = "在这里可以看到学校最大的湖，景色很好，还有很多的天鹅（其实就是一群鸭子......），是打卡拍照的好去处";
			for (int i = 0; i < 11; i++) {
				cout << view[i].id << "、" << view[i].name << '\n';
			}
			//邻接矩阵
			int adj[][MaxSize] = { {0,200,M,450,M,M,M,M,M,M,M},	
				{200,0,200,300,M,M,M,M,M,M,M},
				{M,200,0,150,250,300,M,M,M,M,M},
				{450,300,150,0,M,M,M,550,M,M,M},
				{M,M,250,M,0,150,250,M,M,M,M},
				{M,M,300,M,150,0,300,M,300,M,M},
				{M,M,M,M,250,300,0,100,M,M,600},
				{M,M,M,550,M,M,100,0,M,M,M},
				{M,M,M,M,M,300,M,M,0,400,M},
				{M,M,M,M,M,M,M,M,400,0,300},
				{M,M,M,M,M,M,600,M,M,300,0} };
			//记录从v到v1的最短路径长度
			int dist[MaxSize] = { 0 };
			//图的前驱结点数组
			int path[MaxSize] = { 0 };
			cout << "输入起点：";
			int v;
			cin >> v;
			cout << "输入终点：";
			int v1;
			cin >> v1;
			cout <<view[v].name<< "："<<view[v].introduction << '\n' <<view[v1].name<< "：" << view[v1].introduction << '\n';
			guidance(adj, dist, v, path);
			cout << "最短路径为：" << dist[v1] << '\n';
			cout << "路径：" << '\n';
			find(path, v, v1);
		}
		cout << '\n';
		cout << "是否继续操作（是输入1，否输入0）";
		cin >> y;
	}
	return 0;
}

定义了一些全局变量、结构体和常量，这些东西组合起来构成了你的程序的基础数据结构和参数。下面是我理解的一些概要内容：

1. 常量定义：你定义了MaxSize表示最大顶点数，M表示最大权值，Max表示某个上限值，这些常量可能在后续的算法和数据结构中使用到。

2. 全局结构体：你定义了Team结构体来存储参赛队伍的信息，包括编号、作品名称、学校、赛事类别、参赛者、指导老师和答辩时间。另外，你还定义了BTree结构体来表示二叉排序树的节点，其中包括关键字值、队伍基本信息以及左右孩子指针。此外，你还定义了View结构体来表示景点的信息，包括id、名称和介绍。

3. 全局数组：你定义了一个名为teams的数组来存储参赛队伍的信息，以及两个辅助数组s和s1来存储查找出来的参赛队伍信息。另外，你定义了一个名为view的数组来存储景点的信息。

4. 全局变量：你定义了Count来记录队伍的数量，以及ASL来存储平均查找长度。

在这些基础数据结构的基础上，你很可能会在后续的代码中对这些信息进行存储、查找、处理等操作。希望这些全局数据结构对你有所帮助。

int const MaxSize = 11;	//最大顶点数
int const M = 9999;		//最大权值
int const Max = 500;
double ASL=0;		//平均查找长度
using namespace std;
 struct Team {
	 //参赛作品编号
	int number;
	//参赛作品名称
	string offering;
	//参赛学校
	string school;
	//赛事类别
	string category;
	//参赛者
	string name;
	//指导老师
	string teacher;
	//答辩时间
	int time;
}teams[Max];
Team s[Max],s1[Max];		//用一个数组存储查找出来的参赛队伍
struct BTree {
	//关键字值
	int number;
	//存储队伍基本信息
	Team* t;
	//结点的左右孩子指针
	BTree* lchild, * rchild;
};
struct View {
	//读取文件
	int id;				
	//景点名称
	string name;		
	//景点介绍
	string introduction;
}view[MaxSize];
int Count = 0;		//有多少个队伍

这个函数看起来是用来去除字符串中的空格（包括空格、制表符等）的。函数接受一个string类型的参数s，并按引用进行传递，这样可以直接修改调用函数时传入的字符串。

函数首先定义了一个整型变量index，并在字符串s不为空的情况下进入了一个while循环。在循环中，使用了string的find函数来查找字符串s中下一个制表符的位置，并将其索引赋给index。如果找到了制表符，则使用erase函数将该制表符从字符串中删除，从而实现了去除空格的操作。

需要注意的是，这段代码只能去除制表符(\t)，如果需要去除其他空白字符，可以在函数中进行相应的修改。另外，这段代码没有处理字符串首尾的空格，如果需要去除首尾空格，可以使用string的erase和find_first_not_of等函数来实现。

void Del_space(string& s) {    //去除字符串中的空格
	int index = 0;
	if (!s.empty()) {
	while ((index = s.find('\t', index)) != string::npos) { 
			s.erase(index, 1);
		}
	}
}

这段代码是一个读取文件的函数，功能是从名为 “team.txt” 的文件中读取数据，并将每行数据解析成Team结构体的实例，然后存储到名为teams的全局数组中。

下面是代码的大致流程：

1. 首先尝试打开名为 “team.txt” 的文件，并进行错误检查，如果打开文件失败，则输出错误信息并退出函数。

2. 接着定义了一个string类型的变量line，用来存储从文件中读取的每一行数据。

3. 然后进入一个while循环，使用getline函数从文件中逐行读取数据，然后针对每一行的数据进行解析。

4. 在每行数据解析的过程中，首先创建了一个Team类型的实例t，以及一个string类型的变量s，用来暂时存储从每行数据中分割出的子串。

5. 调用Del_space函数去除当前行的空格。

6. 使用stringstream ss(line)将当前行的数据转化为字符串流，然后利用getline函数和stringstream来逐个读取以 “#” 为分隔符的各个字段，并存入t的对应成员中。

7. 将字符串类型的编号s转换为整型数，并存入t的number成员中。

8. 将t存入全局的teams数组中，并增加Count计数器。

9. 循环结束后，输出每个参赛队伍的信息。

10. 最后关闭文件，并输出参赛队伍的总数。

总体来说，这段代码的功能是读取文件中的数据并解析成结构化的信息，然后进行一些简单的处理和输出。需要注意的是，这段代码没有对文件打开失败以及文件格式错误等情况进行详细的处理，你可能需要根据实际情况进行进一步的错误处理和健壮性设计。

//读取文件
void Read() {
	ifstream file("team.txt");
	if (!file){
		cout << "打开文件失败" << endl;
	}
	string line;
	while (getline(file, line)) 
	{
		Team t;
		string s;
		Del_space(line);				//去除该行空格
		stringstream ss(line);
		//getline(ss, s, '#'); 			//实现字符串的输入，初始化ss
		getline(ss >> std::ws, s, '#');    //去除 cin 输入前面的空格，可以使用 std::ws 函数 
		getline(ss >> std::ws, t.offering, '#');
		getline(ss >> std::ws, t.school, '#');
		getline(ss >> std::ws, t.category, '#');
		getline(ss >> std::ws, t.name, '#');
		getline(ss >> std::ws, t.teacher, '#');
		t.number = atoi(s.c_str());	//将编号转化为整形,c_str()返回当前字符串的首字符地址,atoi (表示 ascii to integer)是把字符串转换成整型数的一个函数
		teams[Count] = t;
		Count++;
	}

	for (int i = 0; i < Count; i++)
		cout << "参赛队编号:" << teams[i].number 
		<< "参赛作品名称:" << teams[i].offering 
		<< "参赛学校:" << teams[i].school 
		<< "赛事类别:" << teams[i].category 
		<< "参赛者:" << teams[i].name 
		<< "指导老师:" << teams[i].teacher << endl;
	file.close();
	cout << "总共有 " << Count << " 个队伍" << endl;
}

这个函数实现了向队伍数组中插入新的队伍信息的功能。函数中通过交互式的方式，依次要求用户输入新队伍的编号、作品名称、学校、赛事类别、参赛者以及指导老师的信息。接着，将新的队伍信息插入到teams数组中，并更新队伍数量Count。最后，输出插入队伍的信息，并提示插入成功。

这段代码实现了一个简单的插入功能，但需要注意的是，它只能处理一个队伍的插入操作，如果需要批量插入或者提供更灵活的插入方式，可能需要进一步完善这个函数。此外，对用户输入的有效性（如输入格式、边界值等）也需要进行验证和处理，以确保程序的健壮性。

//插入队伍
void Insert() {
	Team a;
	cout << "请输入添加队伍编号:";
	cin >> a.number;
	cout << "请输入添加队伍的作品名称：";
	cin >> a.offering;
	cout << "请输入添加队伍学校:";
	cin >> a.school;
	cout << "请输入添加队伍的赛事类别:";
	cin >> a.category;
	cout << "请输入添加参赛者:";
	cin >> a.name;
	cout << "请输入添加队伍指导老师:";
	cin >> a.teacher;
	teams[Count] = a;
	cout << "添加成功" << '\n';
	cout << "参赛队编号:" << teams[Count].number << "参赛作品名称:" << teams[Count].offering 
		<< "参赛学校:" << teams[Count].school << "赛事类别:" << teams[Count].category 
		<< "参赛者:" << teams[Count].name << "指导老师:" << teams[Count].teacher << endl;
	Count++;
 
}

这个函数实现了根据指定队伍编号删除队伍信息的功能。首先，函数要求用户输入要删除的队伍编号。然后，函数遍历teams数组，查找与输入编号相匹配的队伍信息。如果找到匹配的队伍信息，输出该队伍的详细信息，并将后续队伍信息往前移动一个位置，然后更新队伍数量Count。最后，给出删除成功的提示。

需要注意的是，这段代码只能删除第一个匹配的队伍信息，无法删除重复的队伍信息或多个队伍信息。如果存在多个相同编号的队伍，可能需要进一步修改代码以实现更复杂的删除逻辑。此外，对用户输入的有效性（如输入格式、边界值等）也需要进行验证和处理，以确保程序的健壮性。

//删除队伍
void Delete(){
	int num;
	cout << "请输入要删除的队伍编号：" << endl;
	cin >> num;
	for(int i=0;i<Count;i++){
		if (teams[i].number == num){
			cout << "删除队伍信息：" << endl;
			cout << "参赛队编号：" << teams[i].number << '\t' << "参赛作品名称：" << teams[i].offering<< '\t' 
				<< "参赛学校：" << teams[i].school << '\t' << "赛事类别：" << teams[i].category << '\t' 
				<< "参赛者：" << teams[i].name << '\t' << "指导老师：" << teams[i].teacher << endl;
			for (int j = i; j < Count; j++) {
				teams[j] = teams[j + 1];
		}
			Count--;
			cout << "删除成功" << endl;
			return;
		}
	}
	 	cout << "不存在此队伍" << endl;
}

这个函数实现了根据指定队伍编号更改队伍信息的功能。首先，函数要求用户输入要修改信息的队伍编号。然后，函数遍历teams数组，查找与输入编号相匹配的队伍信息。如果找到匹配的队伍信息，接着依次要求用户输入新的参赛作品名称、队伍学校、赛事类别、参赛者以及指导老师的信息，然后更新对应队伍的信息。最后，给出修改成功的提示。

这段代码实现了一个简单的更改队伍信息的功能，但需要注意的是，它只能修改第一个匹配到的队伍信息，无法修改重复的队伍信息或多个队伍信息。如果存在多个相同编号的队伍，可能需要进一步修改代码以实现更复杂的更改逻辑。此外，对用户输入的有效性（如输入格式、边界值等）也需要进行验证和处理，以确保程序的健壮性。

//更改队伍信息
void Exchange() {
	int num;
	cout << "输入你要修改那个队伍的信息（输入编号）：";
	cin >> num;
	for (int i = 0; i < Count; i++) {
		if (teams[i].number == num) {
			string s1,s2,s3,s4,s5;
			cout << "请输入更改后参赛作品名称：";
			cin >> s1;
			teams[i].offering = s1;
			cout << "请输入更改后队伍学校：";
			cin >> s2;
			teams[i].school = s2;
			cout << "请输入更改后的队伍的赛事类别：";
			cin >> s3;
			teams[i].category = s3;
			cout << "请输入更改后参赛者：";
			cin >> s4;
			teams[i].name = s4;
			cout << "请输入更改后队伍指导老师：";
			cin >> s5;
			teams[i].teacher = s5;
			break;
		}
	}
	cout << "修改成功" << endl;
}

这段代码实现了向二叉搜索树中插入新结点的功能。其中，二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树，具有以下性质：

• 对于任意结点root，它的左子树中所有结点的值都小于root的值。
• 对于任意结点root，它的右子树中所有结点的值都大于root的值。
• 左右子树都是二叉搜索树。

函数中，首先判断根结点是否为空，如果为空，则创建一个新的结点作为根结点，并设置相应的编号和指针信息。如果根结点不为空，则根据插入结点的编号与根结点的大小进行比较：

• 如果插入结点的编号大于根结点的编号，则将插入结点放入右子树中（递归调用insertBST函数）。
• 如果插入结点的编号小于根结点的编号，则将插入结点放入左子树中（递归调用insertBST函数）。

最后，返回根结点root。这样，递归过程将会不断向下，找到插入结点的正确位置，并构建一个满足二叉搜索树性质的二叉树。

需要注意的是，这段代码只实现了向二叉搜索树中插入新结点的功能，具体的二叉树数据结构BTree和队伍信息结构Team并未提供完整的定义和实现。所以，若要将这段代码应用到实际场景中，还需要完善队伍信息结构以及相应的操作逻辑。

//二叉树插入结点
BTree* insertBST(BTree* root, Team* team) {
	if (root == NULL) {	//当根结点为空时
		BTree* root1 = new BTree();
		root1->number = team->number;
		root1->t = team;
		root1->lchild = NULL;
		root1->rchild = NULL;
		return root1;
	}
	if (root->number < team->number) {		//当根结点的大小小于插入结点的大小
		root->rchild = insertBST(root->rchild, team);
	}
	else if (root->number > team->number){	
		root->lchild = insertBST(root->lchild, team);
	}
	return root;
}

这两段代码实现了在二叉搜索树中按编号搜索节点并返回其深度的功能。

第一段代码是搜索函数Sreachnum，它接收二叉搜索树的根节点root、待搜索的编号number和当前深度depth作为参数。在函数中，首先判断根节点是否为空，如果为空则返回NULL。然后判断根节点的编号与待搜索编号的关系：

• 如果根节点的编号等于待搜索编号，则直接返回根节点root。
• 如果根节点的编号小于待搜索编号，则递归调用Sreachnum函数在右子树中搜索。
• 如果根节点的编号大于待搜索编号，则递归调用Sreachnum函数在左子树中搜索。

需要注意的是，在代码中，第一个if判断后紧接着两个if-else语句，导致最后一个if-else永远无法执行，因此可以删除最后一个if-else语句，只保留其中的return NULL语句。

第二段代码是计算ASL（Average Search Level，平均搜索层数）的函数countASL，它也接收二叉搜索树的根节点root、待搜索的编号number和当前深度depth作为参数。在函数中，首先同样判断根节点是否为空，如果为空则返回0。然后进行类似的递归搜索过程，但不同的是，当找到待搜索编号对应的节点时，直接返回当前深度depth。

这两段代码结合起来，可以在二叉搜索树中按编号搜索节点，并计算出所搜索节点的深度，从而用来计算ASL。不过需要注意在实际应用中，还需要对ASL的计算加以分析和处理，以便完善二叉搜索树的使用和优化。

//按编号搜索
BTree* Sreachnum(BTree* root, int number,int depth) {
	
	if (root == NULL)return NULL;
	if (root->number == number) {
		return root;
	}
	if (root->number < number) {
		return Sreachnum(root->rchild, number,depth+1);
	}
	else return Sreachnum(root->lchild, number,depth+1);
	if (root->number != number)return NULL;
}
//返回编号的深度，用来计算ASL
int countASL(BTree* root, int number, int depth) {
	if (root == NULL)return 0;
	if (root->number == number) {
		return depth;
	}
	if (root->number < number) {
		return countASL(root->rchild, number, depth + 1);
	}
	else return countASL(root->lchild, number, depth + 1);
	if (root->number != number)return 0;
}

这段代码实现了将相邻两个归并段合并成一个有序段的算法。

在函数中，参数low表示归并段的起始位置，mid表示归并段的分界位置，high表示归并段的末尾位置。该算法采用了归并排序的思想，分为以下几个步骤：

1. 初始化变量i、j和k为归并段的起始位置。
2. 进入一个循环，当i小于等于mid且j小于等于high时，比较s[i].number和s[j].number的大小：
   • 如果s[i].number小于s[j].number，将s[i]复制到s1[k]，并将i和k各自递增1。
   • 如果s[i].number大于等于s[j].number，将s[j]复制到s1[k]，并将j和k各自递增1。
3. 当循环结束后，可能存在一个归并段已经遍历完了，另一个归并段还有剩余的元素。接着使用两个while循环将剩余的元素复制到s1数组中。
4. 最后，使用一个for循环将s1数组中的元素复制回s数组。

这样，通过逐个比较和复制元素的操作，将相邻两个归并段合并成一个有序段。

需要注意的是，在这段代码中，可能存在s1和s数组的定义和初始化。同时，还要保证传入函数的归并段范围是正确的，并且数组中的元素具备可以进行比较和赋值的属性。

//将相邻两个归并段合并成一个有序段的算法
void merge(int low, int mid, int high){
	int i = low, j = mid + 1, k = low;
	while (i <= mid && j <= high){
		if (s[i].number < s[j].number)
			s1[k++] = s[i++];
		else
			s1[k++] = s[j++];
	}
	while (i <= mid)
		s1[k++] = s[i++];
	while (j <= high)
		s1[k++] = s[j++];
	for (int i = low; i <= high; i++)
		s[i] = s1[i];
}

这段代码实现了归并排序算法的总体部分。归并排序是一种经典的排序算法，它采用分治策略，将待排序数组递归地分成小的子数组，然后将这些子数组进行合并，直到整个数组有序为止。

在该算法的mergesort函数中，参数x表示归并排序的起始位置，参数y表示归并排序的结束位置。首先进行递归基的判断：

• 如果x大于等于y，表示当前的数组范围已经小到只有一个元素或者没有元素，无需排序，直接返回。
  然后，计算出中间位置mid，并分别对左半部分和右半部分进行递归调用mergesort：
• 递归调用mergesort(x, mid)，对数组的左半部分进行排序。
• 递归调用mergesort(mid + 1, y)，对数组的右半部分进行排序。
  最后，调用merge函数将左右两部分合并成一个有序的整体。

整体来看，这段代码通过递归的方式将数组不断地分解成更小的部分，然后通过merge函数将这些小部分合并成有序的整体，从而实现了归并排序算法。需要注意的是，在实际应用中，需要对数组的正确性、边界条件和结果的处理进行细致地考量和完善。

//归并排序算法总体部分
void mergesort(int x, int y){
	if (x >= y) return;
	int mid = (x + y) / 2;
	mergesort(x, mid);
	mergesort(mid + 1, y);
	merge(x, mid, y);
}

这段代码实现了按学校名称搜索并输出相关信息的功能。

在函数Searchsch中，参数school表示待搜索的学校名称。函数通过遍历整个teams数组，查找学校名称匹配的记录，并将其存储在s数组中。

首先，变量j初始化为0，用于记录匹配记录在s数组中的位置。然后，通过一个for循环遍历整个teams数组：

• 如果当前记录的学校名称与待搜索的学校名字相等，将该记录复制到s数组中，并将j递增1。

完成遍历后，调用mergesort函数对s数组进行归并排序，以确保输出结果按照编号排序。

最后，再通过一个for循环遍历s数组，输出匹配记录的相关信息。

需要注意的是，在这段代码中，数组s的定义和初始化未给出，同时对teams数组的正确性和边界条件进行了默认假设。此外，还需要根据具体情况设计和完善相关的数据结构和函数。

//按学校搜索
void Searchsch(string school) {	
	int j = 0;
	for (int i = 0; i < Max; i++) {
		if (teams[i].school == school) {
			s[j] = teams[i];
			j++;
		}
	}
	//归并排序
	mergesort(0, j-1);
	for (int i = 0; i < j; i++)
		cout << s[i].number <<'\t'<<s[i].offering <<'\t' << s[i].category <<'\t' << s[i].name <<'\t' << s[i].teacher <<'\n';
}

这段代码实现了一个模拟的决赛室内叫号系统。

在函数Call中，首先定义了存放参赛类型的字符串数组type和存放决赛室名称的字符串数组room。然后，定义了一个二维数组Team t[4][100]，用于存放四个决赛室的队伍。

接下来，通过两个嵌套的for循环，将队伍按照参赛类型分组，将符合类型要求的队伍存放到相应的决赛室数组中。

然后，使用srand函数和当前时间作为种子，生成随机数来模拟队伍的时间。接着，使用嵌套的for循环遍历每个决赛室的队伍，模拟叫号系统的过程：

• 初始化小时hour为8，分钟minute为0。
• 输出当前决赛室的名称。
• 使用变量j来迭代每个决赛室的队伍数组，当队伍的参赛类型不为空时，执行以下操作：
  • 生成随机的比赛时间t[i][j].time。
  • 如果分钟数超过60，则小时数加1，并将分钟数减去60。
  • 输出比赛时间、队伍的名称信息。
  • 将分钟数增加之前生成的随机比赛时间。
  • j递增1，执行下一轮的叫号操作。

通过以上步骤，模拟了决赛室内叫号系统的功能。需要注意的是，该代码中的teams数组和Count变量没有给出具体的定义和初始化，因此在实际应用中需要根据需求设计和完善相关的数据结构和函数，并确保数组的正确性和边界条件。另外，该代码中使用了time(NULL)函数作为随机数种子，因此需要包含头文件<ctime>。

void Call() {
    //存放所有的参赛类型
    string type[4] = {"A", "B", "C", "D"};

    //存放决赛室名称
    string room[4] = {"A", "B", "C", "D"};

    //定义四个决赛室存放队伍的数组
    Team t[4][100];

    //自定义四种类型，将队伍分成四组
    for (int i = 0; i < 4; i++) {
        int k = 0;
        for (int j = 0; j < Count; j++) {
            if (type[i] == teams[j].category) {
                t[i][k] = teams[j];
                k++;
            }
        }
    }

    //模拟决赛室内叫号系统
    srand((unsigned int)time(NULL));
    for (int i = 0; i < 4; i++) {
        int hour = 8;
        int minute = 0;
        cout << "决赛室：" << room[i] << '\n';
        int j = 0;
        while (t[i][j].category != "") {
            t[i][j].time = rand() % (10 - 5 + 1) + 5;
            if (minute > 60) {
                hour++;
                minute -= 60;
            }
            cout << hour << ":" << minute << '\t' << t[i][j].offering << '\n';
            minute += t[i][j].time;
            j++;
        }
    }
}

这段代码实现了一个导航系统，用于计算从源顶点到其他顶点的最短路径和路径信息。

函数guidance的参数包括邻接矩阵a、距离数组dist、源顶点v和路径数组path。

首先，定义了一个数组used用于判断顶点是否被访问过。通过一个for循环来初始化顶点的used数组，将源顶点v的used设为1，其余顶点的used设为0。

然后，通过另一个for循环来初始化距离数组dist和路径数组path。

• 如果当前顶点下标i等于源顶点v，将dist[i]设为0，表示源顶点到自身的距离为0。
• 否则，将dist[i]设为邻接矩阵中从源顶点v到顶点i的距离。
• 如果dist[i]小于一个很大的值M（这里未给出具体值），将路径数组path[i]设为源顶点v，表示源顶点直接到达顶点i。
• 否则，将路径数组path[i]设为-1，表示无法直接从源顶点到达顶点i。

接下来，通过两个嵌套的for循环来计算最短路径和更新路径信息。

• 外层循环从1到MaxSize-1（这里未给出具体值），表示对除源顶点外的所有顶点进行遍历。
• 内层循环用于选取未被访问过的顶点中距离源顶点最近的顶点，并记录其下标为k。
• 将选取的顶点k标记为已访问。
• 再次通过一个嵌套的for循环遍历所有未被访问的顶点：
  • 如果顶点j等于源顶点v，继续下一次循环。
  • 如果通过顶点k中转到顶点j的距离之和小于源顶点到顶点j的距离，并且顶点j未被访问过，更新顶点j的距离和路径信息。

通过以上步骤，最后得到了源顶点到其他顶点的最短路径和路径信息，分别存储在dist和path数组中。

需要注意的是，该代码中未给出具体的数值范围和边界条件，因此在实际应用中需要根据需求设计和完善相关的数据结构和函数，并确保邻接矩阵a的正确性和给出合理的M值。另外，该代码中使用了maxSize常量，但没有给出具体值，这也需要根据实际情况进行定义。

void guidance(int a[][MaxSize],int dist[],int v,int path[]) {		//导航系统
	int k;
	int used[MaxSize];		//判断顶点是否被访问过
	for (int i = 0; i < MaxSize; i++) {
		if (i == v)used[v] = 1;
		else	used[i] = 0;		//初始化顶点的used都为0
	}
	for (int i = 0; i < MaxSize; i++) {		//初始化dist
		if (i == v)dist[i] = 0;				//v到自身的长度为0
		else
			dist[i] = a[v][i];			//将邻接矩阵中，v到各点的距离存放进去
		if (dist[i] < M)path[i] = v;	//当v到各地的距离不是oo时，将各点的前驱直接记成v
		else path[i] = -1;				//否则，记成-1
	}
	for (int i = 1; i < MaxSize; i++) {
		int min;
		min = 9999;
		for (int j = 0; j < MaxSize; j++) {
			if (j == v)continue;
			if (!used[j] && min > dist[j]) {		//当顶点未被访问且小于min时，将最短路径赋给min，并保存该顶点下标
				min = dist[j];
				k = j;
			}
		}
		used[k] = 1;		//将该顶点标为已被访问
		for (int j = 0; j < MaxSize; j++) {
			if (j == v)continue;
			if ((dist[k] + a[k][j]) < dist[j] && !used[j]) {		//当v到某个顶点的距离大于通过上述顶点中转到该点的距离时，修改dist值
				dist[j] = dist[k] + a[k][j];
				path[j] = k;		//将k设为j的前驱
			}
		}
	}
}

这段代码实现了输出从源顶点到目标顶点的最短路径。

函数find的参数包括路径数组path、源顶点v和目标顶点v1。

首先，定义了变量s用于存储目标顶点v1的前驱顶点。

然后，通过一个条件判断来确定如何输出路径：

• 如果目标顶点v1的前驱顶点是源顶点v，则说明目标顶点v1直接从源顶点v可达，直接输出源顶点v。
• 否则，说明目标顶点v1需要经过其他顶点中转才能到达，递归调用find函数，查找源顶点v的后继顶点，将结果存储在s中。

最后，输出->符号和目标顶点v1，表示从源顶点到目标顶点的路径。

需要注意的是，该代码中并未给出完整的输出语句，只给出了路径的输出逻辑。在实际应用中，可以根据需求设计和完善相应的输出语句。另外，该代码中使用了递归调用来输出路径，因此在实际应用中需要考虑路径的输出顺序和格式，并确保路径数组path的正确性和给出合理的源顶点v和目标顶点v1。

void find(int path[],int v,int v1) {	//输出路径
	int s;
	if (path[v1] == v) {		//当v1的前驱是v时，输出v
		cout << v;
	}
	else {			//当v1的前驱不是v时，递归调用，查找v的后继
		s = path[v1];	
		find(path,v,s); }
	cout << "->" << v1;
	return;
}

这段代码定义了一个名为list的函数，用于打印出一个学生竞赛系统的目录或菜单。

在这个函数中，通过一系列的cout语句，按照特定的格式打印了学生竞赛系统的功能列表，包括功能编号和对应的功能描述。

用户在看到这个目录后，可以根据编号选择相应的功能。这种设计使得用户可以清晰地了解系统提供的功能，并能够快速选择自己需要的操作。

需要注意的是，这里只是打印了目录，并没有实际的功能实现。具体每个功能对应的操作需要在相应的函数中进行实现。

//目录
void list() {
	cout << "学生竞赛系统1.0" << '\n';
	cout << "请输入您的选择：（功能前的数字）" << '\n';
	cout << "1.添加队伍" << '\n';
	cout << "2.删除队伍" << '\n';
	cout << "3.修改队伍信息" << '\n';
	cout << "4.查找队伍" << '\n';
	cout << "5.按参赛学校查询参赛团队" << '\n';
	cout << "6.决赛叫号系统" << '\n';
	cout << "7.校园导航系统" << '\n';
}

这段代码是一个主函数main，实现了根据用户选择进行不同功能操作的学生竞赛系统。

首先，定义了一个整型变量y，用于控制是否继续操作。通过调用函数Read()来读取数据。

然后，通过一个循环，先调用函数list()来显示系统的功能目录，然后根据用户的选择执行相应的操作。

根据用户输入的不同数字x，执行相应的操作：

• 如果x等于1，调用函数Insert()来添加队伍。
• 如果x等于2，调用函数Delete()来删除队伍。
• 如果x等于3，调用函数Exchange()来修改队伍信息。
• 如果x等于4，先创建二叉排序树，然后用户输入要查找的参赛队编号number1，调用函数Sreachnum按编号查找参赛队伍，并输出相关信息。
• 如果x等于5，用户输入要查找的参赛学校Sea_school，调用函数Searchsch按参赛学校查询参赛团队。
• 如果x等于6，调用函数Call()实现决赛叫号系统。
• 如果x等于7，首先初始化了一个包含校园地点信息的数组view[]，然后用户输入起点和终点，调用函数guidance计算最短路径并调用函数find输出路径。

在每次操作结束后，询问用户是否继续操作，根据用户输入的y来决定是否继续执行循环。

需要注意的是，该代码中使用了一些函数，如Read()、Insert()、Delete()、Exchange()、Sreachnum()、Searchsch()、Call()等，在实际应用中需要根据需求设计和完善这些函数，并保证相关的数据结构和算法的正确性。同时，该代码中使用了一些未给出的变量和常量，例如Max、Count、ASL等，需要根据实际情况进行定义和初始化。

int main() {
	int y = 1;
	Read();
	while (y != 0) {
		list();
		int x;
		cin >> x;
		if(x==1)Insert();
		if(x==2)Delete();
		if(x==3)Exchange();
		BTree* root = NULL;
		//创建二叉排序树
		for (int i = 0; i < Max; i++) {
			root = insertBST(root, &teams[i]);
		}
		if (x == 4) {
			cout << "输入要查找的参赛队编号：";
			int number1;
			cin >> number1;
			BTree* s = new BTree();
			s = Sreachnum(root, number1, 1);			//按编号查找
			if (s != NULL) {
				cout << "参赛作品名称：" << s->t->offering << '\t' << "参赛学校：" << s->t->school
					<< '\t' << "赛事类型：" << s->t->category << '\t' << "参赛者："
					<< s->t->name << '\t' << "指导老师：" << s->t->teacher << endl;
 
				double s1 = 0;
				cout << "ASL=(";
				for (int i = 0; i < Count; i++) {
					int s2;
					s2 = countASL(root, teams[i].number, 1);
					s1 += s2;
					if (i == Count - 1)cout << s2 << ")*1/" << Count << " = ";
					else cout << s2 << "+";
				}
				ASL = s1 / Count;
				cout << ASL << '\n';
			}
			else cout << "查找失败！" << '\n';
		}
		if (x == 5) {
			cout << "输出要查找的参赛学校：";
			string Sea_school;
			cin >> Sea_school;
			Searchsch(Sea_school);				//按参赛学校查找参赛团队
		}
		if (x == 6) {
			cout << "叫号系统" << '\n';
			Call();						//叫号系统
		}
		if (x == 7) {
			cout << "校园导游系统" << '\n';
			for (int i = 0; i < 11; i++) {
				view[i].id = i;
			}
			view[0].name = "西区宿舍";
			view[0].introduction = "学生公寓区，有许多宿舍楼，是学生们休息、娱乐的地方,属于新建的宿舍楼，位于信阳农林学院西边，宿舍有空调、独立卫生间，二十四小时热水。";
			view[1].name = "学子食堂";
			view[1].introduction = "位于馨苑后边，有教工餐厅，有三层楼，菜品丰富、多样";
			view[2].name = "操场";
			view[2].introduction = "含有足球场，篮球场，排球场等。学生可以在这里踢足球、健身以及举办各种活动";
			view[3].name = "文体中心";
			view[3].introduction = "学校一餐三楼，可以举办晚会";
			view[4].name = "一号学楼";
			view[4].introduction = "公共教学大楼一号楼，是学生们上课学习的地方";
			view[5].name = "双创中心大楼";
			view[5].introduction = "信阳农林学院创新创业大楼，在行政楼对面";
			view[6].name = "图书馆";
			view[6].introduction = "是学校标志性建筑，图文咨讯中心，可以在这里自主学习，含有智能借还书系统";
			view[7].name = "新食堂";
			view[7].introduction = "学校新建的餐厅，位于三号教学楼旁边，菜品丰富、多样";
			view[8].name = "信息工程学院";
			view[8].introduction = "是计算机学院老师办公的地方，计算机专业的学生在这里进行实验和项目开发";
			view[9].name = "行政楼";
			view[9].introduction = "行政办公大楼，用于日常办公";
			view[10].name = "楚韵湖";
			view[10].introduction = "在这里可以看到学校最大的湖，景色很好，还有很多的天鹅（其实就是一群鸭子......），是打卡拍照的好去处";
			for (int i = 0; i < 11; i++) {
				cout << view[i].id << "、" << view[i].name << '\n';
			}
			//邻接矩阵
			int adj[][MaxSize] = { {0,200,M,450,M,M,M,M,M,M,M},	
				{200,0,200,300,M,M,M,M,M,M,M},
				{M,200,0,150,250,300,M,M,M,M,M},
				{450,300,150,0,M,M,M,550,M,M,M},
				{M,M,250,M,0,150,250,M,M,M,M},
				{M,M,300,M,150,0,300,M,300,M,M},
				{M,M,M,M,250,300,0,100,M,M,600},
				{M,M,M,550,M,M,100,0,M,M,M},
				{M,M,M,M,M,300,M,M,0,400,M},
				{M,M,M,M,M,M,M,M,400,0,300},
				{M,M,M,M,M,M,600,M,M,300,0} };
			//记录从v到v1的最短路径长度
			int dist[MaxSize] = { 0 };
			//图的前驱结点数组
			int path[MaxSize] = { 0 };
			cout << "输入起点：";
			int v;
			cin >> v;
			cout << "输入终点：";
			int v1;
			cin >> v1;
			cout <<view[v].name<< "："<<view[v].introduction << '\n' <<view[v1].name<< "：" << view[v1].introduction << '\n';
			guidance(adj, dist, v, path);
			cout << "最短路径为：" << dist[v1] << '\n';
			cout << "路径：" << '\n';
			find(path, v, v1);
		}
		cout << '\n';
		cout << "是否继续操作（是输入1，否输入0）";
		cin >> y;
	}
	return 0;
}