图的应用
一、 实验目的
1．掌握图的存储思想及其存储实现。
2．掌握图的深度、广度优先遍历算法思想及其程序实现。
3. 掌握连通图的最小生成树和拓扑排序。
二、 实验内容及要求
（1） 键盘输入数据，分别建立一个有向图和一个无向图的邻接表。
（2） 输出该邻接表。
（3） 在有向图的邻接表的基础上计算各顶点的度，并输出。
（4） 采用邻接表存储实现无向图的深度优先遍历。
（5） 采用邻接表存储实现无向图的广度优先遍历。
（6） 在主函数中设计一个简单的菜单，分别调试上述算法。
（7） 以有向图的邻接表为基础输出它的拓扑排序序列。
（8） 以无向图的邻接矩阵为基础实现最小生成树的PRIM算法。
（9） 在主函数中设计一个简单的菜单，分别调试上述算法。
（10） 综合训练：校园导航
a）问题描述：
在给出校园各主要建筑的名称信息及有路线连通的建筑之间的距离（或行进时间）的基础上，利用校园导航系统计算出给定的起点到终点之间距离最近（或行进时间最短）的行进路线。
b设计要求：文件读入或键盘方式读入校园主要建筑信息及建筑间的距离（或行进时间）信息。创建完地图后，以文件形式保存，以免重复创建。计算出给定的起点到终点之间距离最近（或行进时间最短）的行进路线，并输出该路线（包括经过哪些建筑）及其总距离（或总行进时间）。
11)综合训练
地下迷宫探索：假设有一个地下通道迷宫，它的通道都是直的，而通道所有交叉点（包括通道的端点）上都有一盏灯和一个开关。请问你如何从某个起点开始在迷宫中点亮所有的灯并回到起点？
输入格式：
输入第一行给出三个正整数，分别表示地下迷宫的节点数N（1<N≤1000，表示通道所有交叉点和端点）、边数M（M≤3000，表示通道数）和探索起始节点编号S（节点从1到N编号）。随后的M行对应M条边（通道），每行给出一对正整数，分别是该条边直接连通的两个节点的编号。
输出格式：
若可以点亮所有节点的灯，则输出从S开始并以S结束的包含所有节点的序列，序列中相邻的节点一定有边（通道）；否则虽然不能点亮所有节点的灯，但还是输出点亮部分灯的节点序列，最后输出0，此时表示迷宫不是连通图。
由于深度优先遍历的节点序列是不唯一的，为了使得输出具有唯一的结果，我们约定以节点小编号优先的次序访问（点灯）。在点亮所有可以点亮的灯后，以原路返回的方式回到起点。
DS.h
#ifndef DACM_ZSN_DS_H
#define DACM_ZSN_DS_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status;
#endif //DACM_ZSN_DS_H
ALGraph.h
#ifndef DACM_ZSN_ALGRAPH_H
#define DACM_ZSN_ALGRAPH_H
#include "DS.h"
#include "LinkQueue.h"
#ifndef ALGRAPH_H_INCLUDED
#define ALGRAPH_H_INCLUDED
#define N 10
typedef char VertexType;
typedef struct ArcNode {
int adjvex;
int weight;
struct ArcNode *nextarc;
} ArcNode;
typedef struct VNode {
VertexType data;
ArcNode *firstarc;
} VNode, AdjList[N];
typedef struct {
AdjList vertices;
int vexnum, arcnum;
} ALGraph;
#endif // ALGRAPH_H_INCLUDED
int CreateUDG(ALGraph &G);
int CreateDG(ALGraph &G);
int CreateUDN(ALGraph &G);
int CreateDN(ALGraph &G);
int LocateVex(ALGraph G, char v);
int InsertList(ALGraph &G, int i, int j, int w);
void TraverseList(ALGraph G, int v);
int LengthList(ALGraph G, int v);
int FirstAdjVex(ALGraph G, int v);
int NextAdjVex(ALGraph G, int v, int w);
void DFSTraverse(ALGraph G);
void DFS(ALGraph G, int v);
void BFSTraverse(ALGraph G);
void BFS(ALGraph G, int v);
void CountNum(ALGraph G, int *ID);
#endif //DACM_ZSN_ALGRAPH_H
ALGraph.cpp
#include "ALGraph.h"
int visited[N];
Status InitLinkQueue(LinkQueue &LQ) {
LQ.front = LQ.rear = (QueuePtr) malloc(sizeof(QNode));
if (!LQ.front) exit(OVERFLOW);
LQ.front->next = NULL;
return OK;
}
Status EnLinkQueue(LinkQueue &LQ, QElemType e) {
QueuePtr p;
p = (QueuePtr) malloc(sizeof(QNode));
if (!p) exit(OVERFLOW);
p->data = e;
p->next = NULL;
LQ.rear->next = p;
LQ.rear = p;
return OK;
}
Status DeLinkQueue(LinkQueue &LQ, QElemType &e) {
if (LQ.front == LQ.rear) return ERROR;
QueuePtr p;
p = LQ.front->next;
e = p->data;
LQ.front->next = p->next;
if (LQ.rear == p)
LQ.rear = LQ.front;
free(p);
return OK;
}
bool QueueEmpty(LinkQueue Q) {
if (Q.front == Q.rear)
return true;
return false;
}
/*创建一个无向图的邻接表*/
int CreateUDG(ALGraph &G) {
int m, n, k;
char v1, v2;
printf("请输入图G的顶点数和边数：");
scanf("%d %d", &G.vexnum, &G.arcnum);
printf("请输入%d个顶点名字(以空格区分)：", G.vexnum);
for (m = 0; m < G.vexnum; m++) {
scanf(" %c", &G.vertices[m].data); /*请注意输入格式*/
G.vertices[m].firstarc = NULL; /*邻接表初始化为空*/
}
for (k = 1; k <= G.arcnum; k++) {
printf("请输入第%d条边的两个顶点(以字符表示，字符间以空格区分)：\n", k);
scanf(" %c %c", &v1, &v2); /*请注意输入格式*/
m = LocateVex(G, v1);
n = LocateVex(G, v2);
InsertList(G, m, n, 0); /*生成各自的邻接表*/
InsertList(G, n, m, 0);
}
return OK;
}
/*请写出有向图的邻接表的生成函数*/
int CreateDG(ALGraph &G) {
int m, n, k;
char v1, v2;
printf("请输入图G的顶点数和边数：");
scanf("%d %d", &G.vexnum, &G.arcnum);
printf("请输入%d个顶点名字(以空格区分)：", G.vexnum);
for (m = 0; m < G.vexnum; m++) {
scanf(" %c", &G.vertices[m].data); /*请注意输入格式*/
G.vertices[m].firstarc = NULL; /*邻接表初始化为空*/
}
for (k = 1; k <= G.arcnum; k++) {
printf("请输入第%d条边的两个顶点(以字符表示，字符间以空格区分,第一个为尾，第二个为头)：\n", k);
scanf(" %c %c", &v1, &v2); /*请注意输入格式*/
m = LocateVex(G, v1); /*确定v1和v2的下标*/
n = LocateVex(G, v2);
InsertList(G, m, n, 0); /*生成各自的邻接表*/
}
return OK;
}
/*请写出无向带权图的邻接表的生成函数*/
int CreateUDN(ALGraph &G) {
int m, n, k, w;
char v1, v2;
printf("请输入图G的顶点数和边数：");
scanf("%d %d", &G.vexnum, &G.arcnum);
printf("请输入%d个顶点名字(以空格区分)：", G.vexnum);
for (m = 0; m < G.vexnum; m++) {
scanf(" %c", &G.vertices[m].data); /*请注意输入格式*/
G.vertices[m].firstarc = NULL; /*邻接表初始化为空*/
}
for (k = 1; k <= G.arcnum; k++) {
printf("请输入第%d条边的两个顶点和权值(以字符表示，字符间以空格区分)：\n", k);
scanf(" %c %c %d", &v1, &v2, &w); /*请注意输入格式*/
m = LocateVex(G, v1); /*确定v1和v2的下标*/
n = LocateVex(G, v2);
InsertList(G, m, n, w); /*生成各自的邻接表*/
InsertList(G, n, m, w);
}
return OK;
}
/*请写出有向带权图的邻接表的生成函数*/
int CreateDN(ALGraph &G) {
int m, n, k, w;
char v1, v2;
printf("请输入图G的顶点数和边数：");
scanf("%d %d", &G.vexnum, &G.arcnum);
printf("请输入%d个顶点名字(以空格区分)：", G.vexnum);
for (m = 0; m < G.vexnum; m++) {
scanf(" %c", &G.vertices[m].data); /*请注意输入格式*/
G.vertices[m].firstarc = NULL; /*邻接表初始化为空*/
}
for (k = 1; k <= G.arcnum; k++) {
printf("请输入第%d条边的两个顶点和权值(以字符表示，字符间以空格区分,第一个为尾，第二个为头)：", k);
scanf(" %c %c %d", &v1, &v2, &w); /*请注意输入格式*/
m = LocateVex(G, v1); /*确定v1和v2的下标*/
n = LocateVex(G, v2);
InsertList(G, m, n, w); /*生成各自的邻接表*/
}
return OK;
}
/*查找顶点v在邻接表存储法中的下标*/
int LocateVex(ALGraph G, char v) {
int m;
for (m = 0; m < G.vexnum; m++)
if (G.vertices[m].data == v)
return m;
return ERROR;
}
/*在邻接表中插入顶点v的邻接点w*/
int InsertList(ALGraph &G, int m, int n, int w) { // 给新加入的节点分配内存；
ArcNode *p;
p = (ArcNode *) malloc(sizeof(ArcNode));
p->adjvex = n;
p->weight = w;
p->nextarc = G.vertices[m].firstarc;
G.vertices[m].firstarc = p;
return OK;
}
/*遍历顶点v的邻接表*/
void TraverseList(ALGraph G, int v) {
ArcNode *p;
int m;
p = G.vertices[v].firstarc;
while (p) {
m = p->adjvex;
printf(" --> %c ", G.vertices[m].data);
p = p->nextarc;
}
}
/*计算顶点v的邻接表长度*/
int LengthList(ALGraph G, int v) {
ArcNode *p;
int m = 0;
if (G.vertices[v].firstarc == NULL) {
return 0;
}
p = G.vertices[v].firstarc;
m++;
while (p->nextarc != NULL) {
m++;
p = p->nextarc;
}
return m;
}
/*深度优先遍历*/
void DFSTraverse(ALGraph G) {
int m;
for (m = 0; m < G.vexnum; m++)
visited[m] = FALSE;
for (m = 0; m < G.vexnum; m++)
if (!visited[m]) DFS(G, m);
printf("\n");
}
void DFS2(ALGraph G, int v) {
int w;
visited[v] = TRUE; /*访问顶点v， 并置访问标志数组相应分量值*/
printf("%c ", G.vertices[v].data);
for (w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w))
if (!visited[w]) DFS2(G, w); /*递归调用DFS*/
} /*DFS*/
void DFS(ALGraph G, int v)
{
ArcNode *p;
visited[v] = TRUE;
printf("%c ", G.vertices[v].data);
p = G.vertices[v].firstarc;
while (p != NULL)
{
if (!visited[p->adjvex] )
{
DFS(G, p->adjvex);
}
//当递归找到出口时 此时就会运行到下面的语句 即一个结点的遍历走到了头
//此时 再向后走 例如 第一条边的邻接表为 1 2 3 那么当2找到递归出口后
//我们还要进行3的遍历 所以要有语句p=p->nextarc
p = p->nextarc;
}
}
/*在图G中查找顶点v的第一个邻接点*/
int FirstAdjVex(ALGraph G, int v) {
if (G.vertices[v].firstarc)
return G.vertices[v].firstarc->adjvex; /*邻接表的第一个结点信息*/
else
return ERROR;
}
/*在图G中查找顶点v的邻接点w之后的下一个邻接点*/
int NextAdjVex(ALGraph G, int v, int w) {
ArcNode *p;
int m;
p = G.vertices[v].firstarc;
while (p) {
if (p->nextarc == NULL) return ERROR;
m = p->adjvex;
if (m == w) {
w = p->nextarc->adjvex;
break;
}
p = p->nextarc;
}
return w;
}
void BFSTraverse(ALGraph G) {
int m;
for (m = 0; m < G.vexnum; m++)
visited[m] = FALSE;
for (m = 0; m < G.vexnum; m++)
if (!visited[m]) BFS(G, m);
printf("\n");
}
//BFSTraverse
void BFS(ALGraph G, int v) {
QElemType e;
ArcNode *p;
LinkQueue q;
InitLinkQueue(q);
EnLinkQueue(q, v);
visited[v] = TRUE;
while (!QueueEmpty(q)) {
DeLinkQueue(q, e);
printf("%c ", G.vertices[e].data);
p = G.vertices[e].firstarc;
while (p) {
if (!visited[p->adjvex]) {
EnLinkQueue(q, p->adjvex);
visited[p->adjvex] = TRUE;
}
p = p->nextarc;
}
}
}
/*计算有向图中各顶点的度*/
void CountNum(ALGraph G, int *ID) {
ArcNode *p;
int r[G.vexnum], c[G.vexnum];//c为出度，r为入度。
for (int m = 0; m < G.vexnum; m++) {
c[m] = LengthList(G, m);
}
for (int m = 0; m < G.vexnum; m++) {
r[m] = 0;
}
for (int m = 0; m < G.vexnum; m++) {
p = G.vertices[m].firstarc;
while (p) {
r[p->adjvex]++;
p = p->nextarc;
}
}
for (int m = 0; m < G.vexnum; m++) {
ID[m] = c[m] + r[m];
}
}
Main.cpp
#include "ALGraph.h"
int main() {
while (TRUE) {
ALGraph G;
int i;
int flag=0;
printf("\t选择\n");
printf("\t1.无向图\n");
printf("\t2.有向图\n");
printf("\t-1.退出\n");
scanf("%d", &flag);
switch (flag) {
case 1:
CreateUDG(G);
printf("无向图的邻接表为：\n");
break;
case 2:
CreateDG(G);
printf("有向图的邻接表为：\n");
break;
case -1:
system("pause");
return 0;
}
// CreateDG(G);
int Num[G.vexnum];
// printf("无向图的邻接表为：\n");
for (i = 0; i < G.vexnum; i++) {
// printf("%c ——> ", G.vertices[i].data);
printf("%c", G.vertices[i].data);
TraverseList(G, i);
printf("\n");
}
printf("DFS序列：");
DFS(G, 0);
printf("\n");
DFSTraverse(G);
printf("BFS序列：");
BFSTraverse(G);
printf("图中各顶点的度为：\n");
CountNum(G, Num);
for (i = 0; i < G.vexnum; i++) {
if (flag == 1)
printf("图中%d点的度为:%d\n", i + 1, Num[i] / 2);
else
printf("图中%d点的度为:%d\n", i + 1, Num[i]);
}
}
}
== 第二题 ==
AOV_DG.cpp
#include "graph.h"
#include<iostream>
#include<queue>
#include<cstring>
#include<stack>
using namespace std;
int LocateVNode(ALGraph g, int index) {
int flag = 0;
for (int i = 0; i < g.vNum; i++) {
if (g.vertices[i].data==index) {
flag = 1;
return i;
}
}
// if (flag == 0) {
// return -1;//查找失败
// }
return -1;
}
int CreateUDG(ALGraph& g) {
cin >> g.vNum >> g.arcNum;
g.vertices = new VNode[g.vNum];
for (int i = 0; i < g.vNum; i++) {
cin >> g.vertices[i].data;
g.vertices[i].firstArc = NULL;
}
for (int i = 0; i < g.arcNum; i++) {
int v1, v2;
cin >> v1 >> v2;
v1 = LocateVNode(g, v1);
v2 = LocateVNode(g, v2);
ArcNode* p1 = new ArcNode;
p1->adjvex = v2 + 1;
p1->nextArc = g.vertices[v1].firstArc;
g.vertices[v1].firstArc = p1;
ArcNode* p2 = new ArcNode;
p2->adjvex = v1 + 1;
p2->nextArc = g.vertices[v2].firstArc;
g.vertices[v2].firstArc = p2;
}
return 1;
}
int CreateDG(ALGraph& g) {
cin >> g.vNum >> g.arcNum;
g.vertices = new VNode[g.vNum];
for (int i = 0; i < g.vNum; i++) {
cin >> g.vertices[i].data;
g.vertices[i].firstArc = NULL;
g.vertices[i].inDegree = 0;
g.vertices[i].outDegree = 0;
}
for (int i = 0; i < g.arcNum; i++) {
int v1, v2;
cin >> v1 >> v2;
v1 = LocateVNode(g, v1);
v2 = LocateVNode(g, v2);
g.vertices[v2].inDegree++;
g.vertices[v1].outDegree++;
ArcNode* p1 = new ArcNode;
p1->adjvex = v2 + 1;
p1->nextArc = g.vertices[v1].firstArc;
g.vertices[v1].firstArc = p1;
}
return 1;
}
void OutputDegree(ALGraph g) {
for (int i = 0; i < g.vNum; i++) {
cout << g.vertices[i].data << ":";
cout << g.vertices[i].inDegree << " ";
cout << g.vertices[i].outDegree << " ";
cout << g.vertices[i].outDegree + g.vertices[i].inDegree << "\n";
}
}
void OutputDGraph(ALGraph g) {
for (int i = 0; i < g.vNum; i++) {
cout << g.vertices[i].data << ":";
ArcNode* p = g.vertices[i].firstArc;
while (p) {
cout << p->adjvex << " ";
p = p->nextArc;
}
cout << endl;
}
}
void WidthTraverseGraph(ALGraph g) {
queue<int> TraverseList;
int visited[1000];
memset(visited, 0, sizeof(visited));
cout << "v" << g.vertices->data << " ";
visited[0] = true;
TraverseList.push(g.vertices->data);
while (!TraverseList.empty()) {
int u = TraverseList.front();
TraverseList.pop();
ArcNode* p = g.vertices[LocateVNode(g,u)].firstArc;
while (p != NULL) {
if (!visited[LocateVNode(g, p->adjvex)]) {
cout << "v" << p->adjvex << " ";
visited[LocateVNode(g, p->adjvex)] = true;
TraverseList.push(p->adjvex);
}
p = p->nextArc;
}
}
}
int visited[1000];
void DepthTraverseGraph(ALGraph g) {
memset(visited, 0, sizeof(visited));
for (int i = 0; i < g.vNum; i++) {
if (visited[i] == 0) {
Depth_TG(g, i);
}
}
}
void Depth_TG(ALGraph g,int v) {
cout << g.vertices[v].data << " ";
visited[v] = true;
ArcNode* p = g.vertices[v].firstArc;
while (p) {
int w = LocateVNode(g, p->adjvex);
if (!visited[w]) {
Depth_TG(g, w);
}
p = p->nextArc;
}
}
int AOVSort(ALGraph g) {
stack<int> s;
for (int i = 0; i < g.vNum; i++) {
if (g.vertices[i].inDegree == 0) {
s.push(i);
}
}
int m = 0;//计数
queue<int> q;
while (!s.empty()) {
int temp = s.top();
s.pop();
q.push(temp + 1);
m++;
ArcNode* p = g.vertices[temp].firstArc;
while (p) {
int a = p->adjvex;
g.vertices[LocateVNode(g,a)].inDegree--;
if (g.vertices[LocateVNode(g, a)].inDegree == 0) {
s.push(LocateVNode(g, a));
}
p = p->nextArc;
}
}
if (m < g.vNum) {
return -1;
}
else {
while (!q.empty()) {
cout << "v" << q.front() << " ";
q.pop();
}
return 1;
}
}
graph.h
//
// Created by AdministratorYWJ on 2022/5/6.
//
#ifndef DACM_ZSN_GRAPH_H
#define DACM_ZSN_GRAPH_H
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#define NOTEXIST -1
#define BEGIN -1
#define MAXVEX 100
#define INFINITY 65535
#define TRUE 1
#define FALSE 0
typedef int EdgeType;
typedef char VertexType;
int dist[MAXVEX]; //dist指 从 该点到被收录的各点中 距离的最小值
typedef struct Graph {
VertexType vex[MAXVEX];
EdgeType edge[MAXVEX][MAXVEX];
int vex_num, edge_num;
}Graph;
char read_char();
int get_pos(Graph g,char ch);
void create_graph(Graph *g);
void Prim(Graph g,int start);
void print_graph(Graph g);
typedef struct ArcNode {
int adjvex;
struct ArcNode* nextArc;
}ArcNode; //边节点
typedef struct VNode {
int data;
int inDegree, outDegree;
ArcNode* firstArc;
}VNode, * AdjList;
typedef struct {
int vNum, arcNum;
AdjList vertices;
}ALGraph;
int LocateVNode(ALGraph g, int index);
int CreateUDG(ALGraph& g);
int CreateDG(ALGraph& g);
void OutputDegree(ALGraph g);
void OutputDGraph(ALGraph g);
void WidthTraverseGraph(ALGraph g);
void Depth_TG(ALGraph g, int v);
int AOVSort(ALGraph g);
#endif //DACM_ZSN_GRAPH_H
Matrix_Prim.cpp
//
// Created by AdministratorYWJ on 2022/5/6.
//
#include "graph.h"
char read_char()
{
char ch;
do {
ch = getchar();
} while (!isalpha(ch));
return ch;
}
//get位置
int get_pos(Graph g, char ch)
{
int i;
for (i = 0; i < g.vex_num; i++) {
if (g.vex[i] == ch)
return i;
}
return -1;
}
//创建图
void create_graph(Graph *g)
{
int i, j, k;
printf("请输入顶点数与边数:\n");
scanf("%d%d", &g->vex_num, &g->edge_num);
//处理边的权重，0或无穷大
for (i = 0; i < g->vex_num; i++) {
for (j = 0; j < g->vex_num; j++) {
if (i == j) {
g->edge[i][j] = 0;
}
else
g->edge[i][j] = INFINITY;
}
}
printf("请输入顶点信息:\n");
for (i = 0; i < g->vex_num; i++) {
g->vex[i] = read_char();
}
printf("请输入边的信息:\n");
char c1, c2;
int p1, p2, w;
for (k = 0; k < g->edge_num; k++) {
c1 = read_char();
c2 = read_char();
scanf("%d", &w);//权重，可以不选
p1 = get_pos(*g, c1);
p2 = get_pos(*g, c2);
g->edge[p1][p2] = w;//有向边的权重
g->edge[p2][p1] = w;
}
}
void Prim(Graph g, int start)
{
int sum = 0;
int index = 0;
int i, j;
char prims[MAXVEX];
prims[index++] = g.vex[start];
for(i = 0; i < g.vex_num; i++ ){
dist[i] = g.edge[start][i];
}
dist[start] = 0; //需要
int min, u, v;
int pre;
for(i = 0; i < g.vex_num; i++ ){
if(start == i)
continue;
min = INFINITY;
for(j = 0; j < g.vex_num; j++ ){
if(dist[j] != 0 && dist[j] < min){
min = dist[j];
u = j;
}
}
if(dist[u] != 0)// not really needed anymore.
prims[index++] = g.vex[u];
dist[u] = 0;
for(v = 0; v < g.vex_num; v++ ){
if(dist[v] != 0 && g.edge[u][v] < dist[v])
dist[v] = g.edge[u][v];
}
}
for(i = 1; i < g.vex_num; i++){
min = INFINITY;//可以排除u v两点不存在边的情况
v = get_pos(g, prims[i]);
for(j = 0; j < i; j++ ){
u = get_pos(g, prims[j]);
if(g.edge[u][v] < min){
min = g.edge[u][v];
}
}
sum += min;
}
printf("prim %c = %d\n",g.vex[start],sum);
for(i = 0; i < index; i++ ){
printf("%c ",prims[i]);
}
}
void print_graph(Graph g)
{
int i, j;
for (i = 0; i < g.vex_num; i++) {
for (j = 0; j < g.vex_num; j++) {
if (g.edge[i][j] == INFINITY)
printf("%5c", '*');
else {
printf("%5d", g.edge[i][j]);
}
}
printf("\n");
}
}
Main.cpp
//
// Created by AdministratorYWJ on 2022/5/6.
//
#include "graph.h"
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<iostream>
#include<queue>
#include<cstring>
#include<stack>
void menu(){
int choice;
printf("\t选择\n");
scanf("%d",&choice);
switch (choice) {
case 1:
printf("1.以有向图的邻接表为基础输出它的拓扑排序序列\n");
ALGraph g1;
CreateDG(g1);//创建有向图
AOVSort(g1);//拓扑排序
break;
case 2:
printf("2.以无向图的邻接矩阵为基础实现最小生成树的PRIM算法\n");
Graph g2;
int start, end;
char c1;
create_graph(&g2);
printf("请输入起始点:\n");
c1 = read_char();
start = get_pos(g2, c1);
Prim(g2, start);
getchar();
break;
case -1:
system("pause");
return;
}
}
int main(){
while (1){
menu();
return 0;
}
}
生命依靠吸收负熵，避免了趋向平衡的衰退
浙公网安备 33010602011771号