C++实现图的遍历和最短路径
摘自：https://blog.csdn.net/qq_45694646/article/details/106764026
C++实现图的基本操作
数据结构之图（存储，遍历，最短路径）
图是一种比线性表和树更为复杂的数据结构，它是“多对多”的关系。图（Graph）G是由两个集合V和E组成，记为G=（V,E）。
一、图的邻接矩阵存储
邻接矩阵法来表示图，需要用一个二维数组来存储邻接矩阵，一个一维数组来存储顶点信息。用邻接矩阵来存储图有它的优点也有它的缺点：
优点：容易实现图的操作，如：求某顶点的度、判断顶点之间是否有边、找顶点的邻接点等等。
缺点：n个顶点需要n*n个单元存储边;空间效率为O(n2)。 对稀疏图而言尤其浪费空间。
代码实现
#define MaxInt 32767 //表示极大值 即无穷大 #define MVNum 100 //最大顶点数 typedef string VerTexType; //设顶点的数据类型为string，需#include<string> typedef int ArcType; //设权值类型为整型 typedef struct { VerTexType vexs[MVNum]; //顶点表 ArcType arcs[MVNum][MVNum]; //邻接矩阵 int vexnum, arcnum; //图的当前点数和边数 }AMGraph;
二、用邻接矩阵来创建无向网
【算法思想】：
1.输入总顶点数和总边数
2.依次输入点的信息存入顶点表中
3.初始化邻接矩阵，使每个权值初始化为极大值
4.构造邻接矩阵
代码实现
bool CreateUDN(AMGraph& G) //采用邻接矩阵表示法，创建无向网 { int i, j, k ; VerTexType v1, v2; ArcType w; cout << "请输入图的顶点总数和边的总数:"; cin >> G.vexnum >> G.arcnum; //输入总顶点数，总边数 cout << "请依次输入顶点信息:" << endl; for (i = 0; i < G.vexnum; ++i) cin >> G.vexs[i]; //依次输入顶点信息 for (i = 0; i < G.vexnum; ++i) for (j = 0; j < G.vexnum; ++j) G.arcs[i][j] = MaxInt;//初始化邻接矩阵，置为无穷大 cout << "请输入边的信息，格式：头，尾，权值" << endl; for (k = 0; k < G.arcnum; ++k) { cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值 i = LocateVex(G, v1);j= LocateVex(G, v2); //确定v1,v2在G中的位置，即顶点数组的下标 G.arcs[i][j] = w; //边<v1,v2>的权值为w G.arcs[j][i] = G.arcs[i][j]; //对称边 } return true; }
LocateVex()函数：查询顶点是否在顶点表中，若在则返回顶点表中的下标；否则返回-1
int LocateVex(AMGraph G, VerTexType u) {//存在则返回u在顶点表中的下标;否则返回-1 int i; for (i = 0; i < G.vexnum; ++i) if (u == G.vexs[i]) return i; return -1; }
输出无向网的信息
void PrintGraph(AMGraph G) { int i, j; cout << "图的邻接矩阵存储信息:" << endl; cout << "顶点信息：" << endl; for (i = 0; i < G.vexnum; i++) cout << i << ":" << G.vexs[i] << endl; //输出顶点信息 cout << "邻接矩阵数据：" << endl; for (i = 0; i < G.vexnum; i++) { for (j = 0; j < G.vexnum; j++) { if (G.arcs[i][j] == MaxInt) cout << left<<setw(6)<<"∞"; else cout << left<<setw(6) << G.arcs[i][j]; } cout << endl; } }
三、图的遍历
遍历的定义：从已给的连通图中某一顶点出发，沿着一些边访遍图中所有的顶点，且使每个顶点仅被访问一次，就叫做图的遍历，它是图的基本运算
遍历的实质：找每个顶点的邻接点的过程
1.深度优先遍历
简单归纳：
(1) 访问起始点v;
(2) 若v的第1个邻接点没访问过，深度遍历此邻接点；
(3) 若当前邻接点已访问过，再找v的第2个邻接点重新遍历
辅助数组：
避免重复访问，bool visited[MVNum];初值为false,若i被访问，则改visited[i]=true;
代码实现：
void DFS_AM(AMGraph G, int v) //深度优先搜索遍历,从第v个顶点开始 { cout <<setw(8)<< G.vexs[v]; visited[v] = true; //访问第v个顶点，并置visited数组对应的值为true for (int w = 0; w < G.vexnum; w++) if ((G.arcs[v][w] != 0) && (!visited[w])) DFS_AM(G,w); //G.arcs[v][w] != 0表示w是v的邻接点，如果w未访问，则递归调用DFS_AM }
DFS算法效率分析：
（1）用邻接矩阵来表示图，遍历图中每一个顶点都要从头扫描该顶点所在行，时间复杂度为O(n2)。
（2）用邻接表来表示图，虽然有 2e 个表结点，但只需扫描 e 个结点即可完成遍历，加上访问 n个头结点的时间，时间复杂度为O(n+e)
（3）结论：稠密图适于在邻接矩阵上进行深度遍历；稀疏图适于在邻接表上进行深度遍历。
2.广度优先遍历
简单归纳：
（1）在访问了起始点v之后，依次访问 v的邻接点
（2）然后再依次访问这些顶点中未被访问过的邻接点
（3）直到所有顶点都被访问过为止
辅助队列：
这里用的是链队列，用顺序队列（循环队列）也可以。
//队列的DAT// typedef int Elemtype; //BFS中队列存放的是图元素下标 typedef int Status; typedef struct QNode { Elemtype data; struct QNode* next; }*QueuePrt; typedef struct { QueuePrt front, rear; //指针形式的对头和队尾指针 }*LinkQueue;
要写出队列的基本操作函数： 初始化 Status InitQuene(LinkQueue q) ； 判空操作 bool QueueEmpty(LinkQueue Q) ； 入队操作 Status EnQueue(LinkQueue q, Elemtype e)； 出队操作Status DeQueue(LinkQueue q, Elemtype* e)； Status InitQuene(LinkQueue q) { if (NULL == q) { return -1; } q->front = NULL; q->rear = NULL; return 0; } bool QueueEmpty(LinkQueue Q) { if (NULL == Q) { return true; } if (NULL == Q->front) { return true; } return false; } Status EnQueue(LinkQueue q, Elemtype e) { QueuePrt QP = NULL; if (NULL == q) { return -1; } QP = (QueuePrt)calloc(1, sizeof(struct QNode)); QP->data = e; QP->next = NULL; if (NULL == q->front) { q->front = QP; q->rear = QP; } else { q->rear->next = QP; q->rear = QP; } return 0; } Status DeQueue(LinkQueue q, Elemtype *e) { QueuePrt QP = NULL; QueuePrt QP_prev = NULL; QueuePrt front = NULL; if (NULL == q || NULL == e) { return -1; } if (QueueEmpty(q)) { return 0; } if (NULL == q->front->next) { q->rear = NULL; } front = q->front; q->front = q->front->next; *e = front->data; free(front); return 0; }
void BFS(AMGraph G, int v) //广度优先遍历 { int i, j; LinkQueue Q; Q =(LinkQueue)malloc(sizeof(LinkQueue)); InitQuene(Q);//采用的是链队列 for (i = 0; i < G.vexnum; i++) visited[i] = false; for (i = 0; i < G.vexnum; i++) { if (visited[i] == false) { cout << setw(8) << G.vexs[v]; visited[v] = true; //访问第v个顶点，并置visited数组对应值为true EnQueue(Q, v); //v进队 while (!QueueEmpty(Q)) //队列非空 { DeQueue(Q, &i);//队头元素出队，并置为i for (j = 0; j < G.vexnum; j++) { if ((G.arcs[i][j] = !MaxInt || G.arcs[i][j] != 0) && visited[j] == false) {//检查i的所有邻接点 visited[j] = true; cout << setw(8) << G.vexs[j];//访问j EnQueue(Q, j);//j入队 } } } } } }
BFS算法效率分析：
（1）如果使用邻接矩阵，则BFS对于每一个被访问到的顶点，都要循环检测矩阵中的整整一行（ n 个元素），总的时间代价为O(n2)。
（2）用邻接表来表示图，虽然有 2e 个表结点，但只需扫描 e 个结点即可完成遍历，加上访问 n个头结点的时间，时间复杂度为O(n+e)。
3.DFS与BFS算法效率比较
（1）空间复杂度相同，都是O(n)(借用了堆栈或队列）；
（2）时间复杂度只与存储结构（邻接矩阵或邻接表）有关，而与搜索路径无关。
四、最短路径算法(Dijkstra算法)
最短路径：在带权有向图中A点（源点）到达B点（终点）的多条路径中，寻找一条各边权值之和最小的路径，即最短路径。
辅助结构：
数组S[n]：记录相应顶点是否已被确定最短距离
数组Dist[n]：记录源点到相应顶点路径长度
数组Path[n]：记录相应顶点的前驱顶点
【Dijkstra算法思想】
（1） 初始化：
● 将源点v0加到S中，即S[v0]=true
● 将v0到各个终点的最短路径长度初始化为权值，即Dist[i]=G.arcs[v0][vi]
● 如果v0和顶点vi之间有弧，则将vi的前驱置为v0，即Path[i]=v0,否则Path[i]=-1
（2） 循环n-1次执行以下操作：
● 选择下一条最短路径的终点vk，使得Dist[k]=Min{Dist[i]|vi∈V-S}
● 将vk加入到S中，即S[vk]=true
● 根据条件更新从v0出发到集合V-S上任一顶点的最短路径的长度，若条件Dist[k]+G.arcs[k][i]<Dist[i]成立，则更新Dist[i]=Dist[k]+G.arcs[k][i],同时更改vi的前驱为vk;Path[i]=k
算法思想：
算法流程图
Dijkstra算法代码实现：
int Dist[MVNum];//Dist存当前找到的最短路径长度 int Path[MVNum];//当前找到的最短路径最后一个中转顶点 bool S[MVNum];//标记当前是否已求出最短路径 void ShortestPath_DIJ(AMGraph G, int v0)//求有向网G的v0顶点到其余顶点的最短路径 { int n, v, i, w, min; n = G.vexnum;//顶点数 for (v = 0; v < n; v++) //n个顶点依次初始化 { S[v] = false;//S初始为空集 Dist[v] = G.arcs[v0][v];//将v0到各个终点的最短路径长度初始化为弧上的权值 if (Dist[v] < MaxInt) Path[v] = v0;//如果v0与v之间有弧，则将v的前驱置为v0 else Path[v] = -1;//无弧，置为-1 } S[v0] = true;//将v0加入S Dist[v0] = 0;//原点到原点 的距离为0 //******初始化结束，开始主循环，每次求得v0到某个顶点v的最短路径，将v加入到S集 for (i = 1; i < n; i++)//n-1个顶点 { min = MaxInt; for (w = 0; w < n; w++) if (!S[w] && Dist[w] < min)//选择一条当前的最短路径，终点为v { v = w; min = Dist[w]; } S[v] = true;//将v加入S for (w = 0; w < n; ++w)//更新从v0出发到集合V-S上所有的最短路径长度 if (!S[w] && (Dist[v] + G.arcs[v][w]) < Dist[w]) { Dist[w] = Dist[v] + G.arcs[v][w];//更新D[w] Path[w] = v;//更改w的前驱为v } } }
显示函数1：输入起点和终点，输出最短路径
void DisplayPath(AMGraph G, int begin, int temp) { if (Path[temp] != -1) { DisplayPath(G, begin, Path[temp]); cout << G.vexs[Path[temp]] << "-->"; } }
显示函数2：输入源点，输出源点到其他各个顶点的最短路径
void PrintPath(AMGraph G, int v) { int i, j, w; int road[MVNum];//用于存储最短路径顶点的下标 for (i = 0; i < MVNum; i++)road[i] = -1; for (i = 0; i < G.vexnum; i++) { if ((S[i] == true) && (i != v)) { cout << "从" << G.vexs[v] << "到" << G.vexs[i] << "的最短路径为：" << "\t\t"<<Dist[i] <<"\t\t"; cout << G.vexs[v] << "->"; w = Path[i];//最短路径途径的顶点 j = 0;//为实现逆转标记途径顶点数 while (w != v)//回溯途径顶点 { road[j] = w; j++; w = Path[w]; } for (j=j-1; j >= 0; j--)//输出最短路径 { cout << G.vexs[road[j]] << "->"; road[j] = -1; } cout << G.vexs[i] << endl; } else cout << "从" << G.vexs[v] << "到" << G.vexs[i] << "不存在路径" << endl; } }
五、具体实验
main函数
int main() { AMGraph G; VerTexType start, destination; //声明起点和终点 int num_start, num_destination; //起点和终点在顶点表中的位置 VerTexType v; int num_v; int choose = -1; cout << "**********************************" << endl; cout << "* 1.创建图" << endl; cout << "* 2.显示图的信息" << endl; cout << "* 3.图的深度优先遍历" << endl; cout << "* 4.图的广度优先遍历" << endl; cout << "* 5.输入起点和终点，显示最短路径" << endl; cout << "* 6.显示源点到各个顶点的最短路径" << endl; cout << "* 7.退出" << endl; cout << "**********************************" << endl; while (choose != 0) { cout << "\n----------------------- \n"; cout<<"\n请输入操作序号:"; cin >> choose; cout << endl; switch (choose) { case 1: CreateUDN(G); break; case 2: PrintGraph(G); break; case 3: cout << "深度优先遍历:" << endl; DFS_AM(G, 0); break; case 4: cout << "广度优先遍历:" << endl; BFS(G); break; case 5: cout << "请依次输入起始点、终点名称："; cin >> start >> destination; //计算起点与终点编号 num_start = LocateVex(G, start); num_destination = LocateVex(G, destination); ShortestPath_DIJ(G, num_start); cout << endl << "最短路径为："; DisplayPath(G, num_start, num_destination); cout << G.vexs[num_destination] << endl; break; case 6: cout << "请输入源点:"; cin >> v; num_v = LocateVex(G, v); ShortestPath_DIJ(G, num_v); PrintPath(G, num_v); break; case 7: exit_1(); break; } } return 0; }
注：本文部分算法源自《数据结构（C语言版）》第二版 严蔚敏 人民邮电出版社
完整代码，测试通过。
// https://blog.csdn.net/qq_45694646/article/details/106764026 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <string> #include <sstream> #include <iostream> #include <iomanip> using namespace std; #define MaxInt 32767 //表示极大值 即无穷大 #define MVNum 100 //最大顶点数 typedef string VerTexType; //设顶点的数据类型为string，需#include<string> typedef int ArcType; //设权值类型为整型 typedef struct { VerTexType vexs[MVNum]; //顶点表 ArcType arcs[MVNum][MVNum]; //邻接矩阵 int vexnum, arcnum; //图的当前点数和边数 }AMGraph; int LocateVex(AMGraph G, VerTexType u); bool CreateUDN(AMGraph& G) //采用邻接矩阵表示法，创建无向网 { int i, j, k ; VerTexType v1, v2; ArcType w; cout << "请输入图的顶点总数和边的总数:"; cin >> G.vexnum >> G.arcnum; //输入总顶点数，总边数 cout << "请依次输入顶点信息:" << endl; for (i = 0; i < G.vexnum; ++i) cin >> G.vexs[i]; //依次输入顶点信息 for (i = 0; i < G.vexnum; ++i) for (j = 0; j < G.vexnum; ++j) G.arcs[i][j] = MaxInt;//初始化邻接矩阵，置为无穷大 cout << "请输入边的信息，格式：头，尾，权值" << endl; for (k = 0; k < G.arcnum; ++k) { cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值 i = LocateVex(G, v1);j= LocateVex(G, v2); //确定v1,v2在G中的位置，即顶点数组的下标 G.arcs[i][j] = w; //边<v1,v2>的权值为w G.arcs[j][i] = G.arcs[i][j]; //对称边 } return true; } int LocateVex(AMGraph G, VerTexType u) {//存在则返回u在顶点表中的下标;否则返回-1 int i; for (i = 0; i < G.vexnum; ++i) if (u == G.vexs[i]) return i; return -1; } void PrintGraph(AMGraph G) { int i, j; cout << "图的邻接矩阵存储信息:" << endl; cout << "顶点信息：" << endl; for (i = 0; i < G.vexnum; i++) cout << i << ":" << G.vexs[i] << endl; //输出顶点信息 cout << "邻接矩阵数据：" << endl; for (i = 0; i < G.vexnum; i++) { for (j = 0; j < G.vexnum; j++) { if (G.arcs[i][j] == MaxInt) cout << left<<setw(6)<<"∞"; else cout << left<<setw(6) << G.arcs[i][j]; } cout << endl; } } bool visited[MVNum] = {false}; //顶点表 void DFS_AM(AMGraph G, int v) //深度优先搜索遍历,从第v个顶点开始 { cout <<setw(8)<< G.vexs[v]; visited[v] = true; //访问第v个顶点，并置visited数组对应的值为true for (int w = 0; w < G.vexnum; w++) if ((G.arcs[v][w] != 0) && (!visited[w])) DFS_AM(G,w); //G.arcs[v][w] != 0表示w是v的邻接点，如果w未访问，则递归调用DFS_AM } #if 1 //队列的DAT// typedef int Elemtype; //BFS中队列存放的是图元素下标 typedef int Status; typedef struct QNode { Elemtype data; struct QNode* next; }*QueuePrt; typedef struct { QueuePrt front, rear; //指针形式的对头和队尾指针 }LinkQueue_T; typedef struct LinkQueue_t{ QueuePrt front, rear; //指针形式的对头和队尾指针 }*LinkQueue; Status InitQuene(LinkQueue q) { if (NULL == q) { return -1; } q->front = NULL; q->rear = NULL; return 0; } bool QueueEmpty(LinkQueue Q) { if (NULL == Q) { return true; } if (NULL == Q->front) { return true; } return false; } Status EnQueue(LinkQueue q, Elemtype e) { QueuePrt QP = NULL; if (NULL == q) { return -1; } QP = (QueuePrt)calloc(1, sizeof(struct QNode)); QP->data = e; QP->next = NULL; if (NULL == q->front) { q->front = QP; q->rear = QP; } else { q->rear->next = QP; q->rear = QP; } return 0; } Status DeQueue(LinkQueue q, Elemtype *e) { QueuePrt QP = NULL; QueuePrt QP_prev = NULL; QueuePrt front = NULL; if (NULL == q || NULL == e) { return -1; } if (QueueEmpty(q)) { return 0; } if (NULL == q->front->next) { q->rear = NULL; } front = q->front; q->front = q->front->next; *e = front->data; free(front); return 0; } void BFS(AMGraph G, int v) //广度优先遍历 { int i = 0; int j = 0; LinkQueue Q = NULL; Q = (LinkQueue)calloc(1, sizeof(struct LinkQueue_t)); InitQuene(Q); // 采用的是链队列 for (i = 0; i < G.vexnum; i++) { visited[i] = false; } for (i = 0; i < G.vexnum; i++) { if (visited[i] == false) { cout << setw(8) << G.vexs[v]; visited[v] = true; //访问第v个顶点，并置visited数组对应值为true // cout << v << endl; EnQueue(Q, v); //v进队 while (!QueueEmpty(Q)) //队列非空 { DeQueue(Q, &i);//队头元素出队，并置为i // cout << "222" << endl; for (j = 0; j < G.vexnum; j++) { if ((G.arcs[i][j] != MaxInt && G.arcs[i][j] != 0) && visited[j] == false) {//检查i的所有邻接点 visited[j] = true; cout << setw(8) << G.vexs[j];//访问j EnQueue(Q, j);//j入队 } //cout << "231" << endl; } } } } } #endif int Dist[MVNum];//Dist存当前找到的最短路径长度 int Path[MVNum];//当前找到的最短路径最后一个中转顶点 bool S[MVNum];//标记当前是否已求出最短路径 void ShortestPath_DIJ(AMGraph G, int v0)//求有向网G的v0顶点到其余顶点的最短路径 { int n, v, i, w, min; n = G.vexnum;//顶点数 for (v = 0; v < n; v++) //n个顶点依次初始化 { S[v] = false;//S初始为空集 Dist[v] = G.arcs[v0][v];//将v0到各个终点的最短路径长度初始化为弧上的权值 if (Dist[v] < MaxInt) Path[v] = v0;//如果v0与v之间有弧，则将v的前驱置为v0 else Path[v] = -1;//无弧，置为-1 } S[v0] = true;//将v0加入S Dist[v0] = 0;//原点到原点 的距离为0 //******初始化结束，开始主循环，每次求得v0到某个顶点v的最短路径，将v加入到S集 for (i = 1; i < n; i++)//n-1个顶点 { min = MaxInt; for (w = 0; w < n; w++) if (!S[w] && Dist[w] < min)//选择一条当前的最短路径，终点为v { v = w; min = Dist[w]; } S[v] = true;//将v加入S for (w = 0; w < n; ++w)//更新从v0出发到集合V-S上所有的最短路径长度 if (!S[w] && (Dist[v] + G.arcs[v][w]) < Dist[w]) { Dist[w] = Dist[v] + G.arcs[v][w];//更新D[w] Path[w] = v;//更改w的前驱为v } } } void DisplayPath(AMGraph G, int begin, int temp) { if (Path[temp] != -1) { DisplayPath(G, begin, Path[temp]); cout << G.vexs[Path[temp]] << "-->"; } } void PrintPath(AMGraph G, int v) { int i, j, w; int road[MVNum];//用于存储最短路径顶点的下标 for (i = 0; i < MVNum; i++)road[i] = -1; for (i = 0; i < G.vexnum; i++) { if ((S[i] == true) && (i != v)) { cout << "从" << G.vexs[v] << "到" << G.vexs[i] << "的最短路径为：" << "\t\t"<<Dist[i] <<"\t\t"; cout << G.vexs[v] << "->"; w = Path[i];//最短路径途径的顶点 j = 0;//为实现逆转标记途径顶点数 while (w != v)//回溯途径顶点 { road[j] = w; j++; w = Path[w]; } for (j=j-1; j >= 0; j--)//输出最短路径 { cout << G.vexs[road[j]] << "->"; road[j] = -1; } cout << G.vexs[i] << endl; } else cout << "从" << G.vexs[v] << "到" << G.vexs[i] << "不存在路径" << endl; } } Status add_edge(AMGraph &G, VerTexType v1, VerTexType v2, ArcType w) { int i = 0; int j = 0; i = LocateVex(G, v1);j= LocateVex(G, v2); //确定v1,v2在G中的位置，即顶点数组的下标 G.arcs[i][j] = w; //边<v1,v2>的权值为w G.arcs[j][i] = G.arcs[i][j]; //对称边 return 0; } bool CreateUDN_test(AMGraph& G) //采用邻接矩阵表示法，创建无向网 { int i, j ; //cout << "请输入图的顶点总数和边的总数:"; G.vexnum = 10; G.arcnum = 12; //输入总顶点数，总边数 //cout << "请依次输入顶点信息:" << endl; G.vexs[0] = "昆明"; G.vexs[1] = "成都"; G.vexs[2] = "西安"; G.vexs[3] = "郑州"; G.vexs[4] = "徐州"; G.vexs[5] = "上海"; G.vexs[6] = "南昌"; G.vexs[7] = "株洲"; G.vexs[8] = "贵阳"; G.vexs[9] = "武汉"; //依次输入顶点信息 for (i = 0; i < G.vexnum; ++i) for (j = 0; j < G.vexnum; ++j) G.arcs[i][j] = MaxInt;//初始化邻接矩阵，置为无穷大 //cout << "请输入边的信息，格式：头，尾，权值" << endl; add_edge(G, "昆明", "成都", 1100); //输入一条边依附的顶点及权值 add_edge(G, "成都", "西安", 842 ); //输入一条边依附的顶点及权值 add_edge(G, "西安", "郑州", 511 ); //输入一条边依附的顶点及权值 add_edge(G, "郑州", "徐州", 349 ); //输入一条边依附的顶点及权值 add_edge(G, "徐州", "上海", 651 ); //输入一条边依附的顶点及权值 add_edge(G, "上海", "南昌", 825 ); //输入一条边依附的顶点及权值 add_edge(G, "南昌", "株洲", 367 ); //输入一条边依附的顶点及权值 add_edge(G, "株洲", "贵阳", 902 ); //输入一条边依附的顶点及权值 add_edge(G, "贵阳", "昆明", 639 ); //输入一条边依附的顶点及权值 add_edge(G, "成都", "贵阳", 967 ); //输入一条边依附的顶点及权值 add_edge(G, "郑州", "武汉", 534 ); //输入一条边依附的顶点及权值 add_edge(G, "武汉", "株洲", 409 ); //输入一条边依附的顶点及权值 return true; } bool CreateUDN_test2(AMGraph& G) //采用邻接矩阵表示法，创建无向网 { int i, j ; //cout << "请输入图的顶点总数和边的总数:"; G.vexnum = 10; G.arcnum = 12; //输入总顶点数，总边数 //cout << "请依次输入顶点信息:" << endl; G.vexs[0] = "西安"; G.vexs[1] = "郑州"; G.vexs[2] = "徐州"; G.vexs[3] = "上海"; G.vexs[4] = "南昌"; G.vexs[5] = "株洲"; G.vexs[6] = "贵阳"; G.vexs[7] = "昆明"; G.vexs[8] = "成都"; G.vexs[9] = "武汉"; //依次输入顶点信息 for (i = 0; i < G.vexnum; ++i) for (j = 0; j < G.vexnum; ++j) G.arcs[i][j] = MaxInt;//初始化邻接矩阵，置为无穷大 //cout << "请输入边的信息，格式：头，尾，权值" << endl; add_edge(G, "西安", "郑州", 511 ); //输入一条边依附的顶点及权值 add_edge(G, "郑州", "徐州", 349 ); //输入一条边依附的顶点及权值 add_edge(G, "郑州", "武汉", 534 ); //输入一条边依附的顶点及权值 add_edge(G, "徐州", "上海", 651 ); //输入一条边依附的顶点及权值 add_edge(G, "上海", "南昌", 825 ); //输入一条边依附的顶点及权值 add_edge(G, "南昌", "株洲", 367 ); //输入一条边依附的顶点及权值 add_edge(G, "武汉", "株洲", 409 ); //输入一条边依附的顶点及权值 add_edge(G, "株洲", "贵阳", 902 ); //输入一条边依附的顶点及权值 add_edge(G, "贵阳", "昆明", 639 ); //输入一条边依附的顶点及权值 add_edge(G, "成都", "贵阳", 967 ); //输入一条边依附的顶点及权值 add_edge(G, "昆明", "成都", 1100); //输入一条边依附的顶点及权值 add_edge(G, "成都", "西安", 842 ); //输入一条边依附的顶点及权值 return true; } bool CreateUDN_test3(AMGraph& G) //采用邻接矩阵表示法，创建无向网 { int i, j ; //cout << "请输入图的顶点总数和边的总数:"; G.vexnum = 7; //输入总 顶点数 G.arcnum = 6; //输入总 边数 //cout << "请依次输入顶点信息:" << endl; G.vexs[0] = "A"; G.vexs[1] = "B"; G.vexs[2] = "C"; G.vexs[3] = "D"; G.vexs[4] = "E"; G.vexs[5] = "F"; G.vexs[6] = "C.1"; //依次输入顶点信息 for (i = 0; i < G.vexnum; ++i) for (j = 0; j < G.vexnum; ++j) G.arcs[i][j] = MaxInt;//初始化邻接矩阵，置为无穷大 //cout << "请输入边的信息，格式：头，尾，权值" << endl; add_edge(G, "A", "B", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "B", "C", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "C", "D", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "D", "E", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "E", "F", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "C", "C.1", 1 ); //输入一条边依附的顶点及权值 return true; } bool CreateUDN_test4(AMGraph& G) //采用邻接矩阵表示法，创建无向网 { int i, j ; //cout << "请输入图的顶点总数和边的总数:"; G.vexnum = 10; //输入总 顶点数 G.arcnum = 9; //输入总 边数 //cout << "请依次输入顶点信息:" << endl; G.vexs[0] = "A"; G.vexs[1] = "B"; G.vexs[2] = "C"; G.vexs[3] = "D"; G.vexs[4] = "E"; G.vexs[5] = "F"; G.vexs[6] = "C.1"; G.vexs[7] = "C.2"; G.vexs[8] = "C.3"; G.vexs[9] = "C.1.1"; //依次输入顶点信息 for (i = 0; i < G.vexnum; ++i) for (j = 0; j < G.vexnum; ++j) G.arcs[i][j] = MaxInt;//初始化邻接矩阵，置为无穷大 //cout << "请输入边的信息，格式：头，尾，权值" << endl; add_edge(G, "A", "B", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "B", "C", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "C", "D", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "D", "E", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "E", "F", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "C", "C.1", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "C.1", "C.2", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "C.2", "C.3", 1 ); //输入一条边依附的顶点及权值 add_edge(G, "C.1", "C.1.1", 1 ); //输入一条边依附的顶点及权值 return true; } int main(int argc, char *argv[]) { AMGraph G; VerTexType start, destination; //声明起点和终点 int num_start, num_destination; //起点和终点在顶点表中的位置 VerTexType v; int num_v; int choose = -1; cout << "**********************************" << endl; cout << "* 1.创建图" << endl; cout << "* 2.显示图的信息" << endl; cout << "* 3.图的深度优先遍历" << endl; cout << "* 4.图的广度优先遍历" << endl; cout << "* 5.输入起点和终点，显示最短路径" << endl; cout << "* 6.显示源点到各个顶点的最短路径" << endl; cout << "* 7.退出" << endl; cout << "**********************************" << endl; CreateUDN_test4(G); while (choose != 0) { cout << "\n----------------------- \n"; cout<<"\n请输入操作序号:"; cin >> choose; cout << endl; switch (choose) { case 1: CreateUDN(G); break; case 2: PrintGraph(G); break; case 3: cout << "深度优先遍历:" << endl; DFS_AM(G, 0); break; case 4: cout << "广度优先遍历:" << endl; BFS(G, 0); break; case 5: cout << "请依次输入起始点、终点名称："; cin >> start >> destination; //计算起点与终点编号 num_start = LocateVex(G, start); num_destination = LocateVex(G, destination); ShortestPath_DIJ(G, num_start); cout << endl << "最短路径为："; DisplayPath(G, num_start, num_destination); cout << G.vexs[num_destination] << endl; break; case 6: cout << "请输入源点:"; cin >> v; num_v = LocateVex(G, v); ShortestPath_DIJ(G, num_v); PrintPath(G, num_v); break; case 7: exit(0); break; } } return 0; }
