判断网的连通性，若是连通网，求其最小生成树。给定源点，求其到其他顶点的最短路径
一、明确问题
（1）创建一个无向网（用邻接矩阵或邻接表存储）；
（2）判断网的连通性；
（3）若是连通网，求其最小生成树；
（4）给定源点，求其到其他顶点的最短路径。
二、问题分析
该实验可以按照标号分成四个板块。
（1）创建一个无向网，本次实验，采用的是邻接矩阵的存储方式。首先，我们需要定义宏变量，用于限制矩阵和数值的最大值；其次，创建一个结构体AMGraph，用于存储邻接矩阵的每个顶点的表示，二维数组，顶点数和边数；然后设置一个子函数void CreateUDN(AMGraph& G)，通过输入的无向网的顶点数和边数，创建创建循环，先将二维数组初始化为最大的int值，然后通过scanf函数分别输入无向网的每条边的权数和顶点标号，赋值给响应的二维数组顶点，由于是无向网所以G.arcs[i][j] = G.arcs[j][i]。最后，我们可以通过两个for函数，打印出输入的无向网的邻接矩阵。
（2）判断网的连通性，本次实验中，采用的是广度优先遍历的方式（BFS）。首先，需要创建几个子函数用于创建队列void InitQueue(sqQueue& Q)、向队列中加入节点void EnQueue(sqQueue &Q, int e)、向队列中删除节点void DeQueue(sqQueue &Q, int &u)、以及判断队列是否为空的函数bool QueueEmpty(sqQueue Q)，本次实验采用的是顺序表的存储方式；其次，为了检验是否遍历，因此创建了一个辅助数组，布尔类型，先初始化为false，遍历到该顶点后将其值改变为true，最终检验该无向网是否是连通网的判定条件就是看该辅助链表visited中是否存在false的节点；然后，创建了三个子函数，int FirstAdjVex(AMGraph G , int v)，int NextAdjVex(AMGraph G , int u , int w)，void BFS (AMGraph G, int v)，分别用于返回顶点v的第一个邻接点，返回顶点v相对于顶点w的下一个邻接点，以及按广度优先非递归遍历连通图G。
（3）若是连通网，求其最小生成树，本实验中求最小生成树采用的是prim算法。首先，扫描起始点c，并且创建一个结构体MinCostEage，用于存储每个顶点的值adjvex和最小的代价lowCost；其次创建一个用于寻找lowCost最小顶点的下标的函数，返回其在G.vexs数组中的序列值；然后创建一个建立最小生成树的函数MiniSpanTree_PRIM，由于n个顶点最小生成树中有n-1条边，因此只需要循环n-1次，就可以找到最小生成树。
（4）给定源点，求其到其他顶点的最短路径，本次实验中寻找路径采用的是迪杰斯特拉算法。首先，创建两个矩阵，路径矩阵PathMatrix和最短距离表ShortPathTable；其次，创建一个辅助矩阵final，用于表示该顶点是否已经是对v0而言的最短距离，赋值1或0；然后先将上述三个矩阵进行初始化，从源点开始，寻找每一个点的最短路径，并对上述三个矩阵进行相对应的调整，外层只需要循环顶点个数-1次，便可算出每个顶点对v0的最短距离；最后用printf语句将其打印下来。
三、主要函数和伪代码
typedef struct{
char vexs[MAX_VERTEX_NUM];//每个顶点的表示
int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//数组
int vexnum, arcnum;//顶点数和边数
}AMGraph;
typedef struct{
int *base;
int front;
int rear;
}sqQueue;
typedef struct MinCostEage{
char adjvex;
int lowCost;
}minside[MAX_VERTEX_NUM];
void InitQueue(sqQueue& Q) {
//创建一个新队列
void EnQueue(sqQueue &Q, int e){
//插入元素e为Q的新的队尾元素
bool QueueEmpty(sqQueue Q){
//判断是否为空队
void DeQueue(sqQueue &Q, int &u){
//队头元素出队并置为u
//确定顶点在G中的位置
int LocateVex(AMGraph G, char v)
void CreateUDN(AMGraph& G)
//创建一个无向网
int FirstAdjVex(AMGraph G , int v){
//返回v的第一个邻接点
int NextAdjVex(AMGraph G , int u , int w){
//返回v相对于w的下一个邻接点
void BFS (AMGraph G, int v){
//按广度优先非递归遍历连通图G
int minimum(minside SZ, AMGraph G){//找lowcost最小的顶点下标
void MiniSpanTree_PRIM(AMGraph G, char u)//建立最小生成树
void ShortPath_DIJ(AMGraph G,int v0 , PathMatrix &P , ShortPathTable &D)//寻找最短路径
四、源代码和运行结果
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXINT 32767
#define MAX_VERTEX_NUM 20
typedef int Boolean;
Boolean visited[MAX_VERTEX_NUM];//全局变量
typedef int PathMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef int ShortPathTable[MAX_VERTEX_NUM];
typedef struct{
char vexs[MAX_VERTEX_NUM];//每个顶点的表示
int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//数组
int vexnum, arcnum;//顶点数和边数
}AMGraph;
typedef struct{
int *base;
int front;
int rear;
}sqQueue;
typedef struct MinCostEage{
char adjvex;
int lowCost;
}minside[MAX_VERTEX_NUM];
void InitQueue(sqQueue& Q) {
//创建一个新队列
Q.base = new int[MAX_VERTEX_NUM];
Q.front = Q.rear = 0;
}
void EnQueue(sqQueue &Q, int e){
//插入元素e为Q的新的队尾元素
if((Q.rear + 1) % MAX_VERTEX_NUM == Q.front)
return;
Q.base[Q.rear] = e;
Q.rear = (Q.rear + 1) % MAX_VERTEX_NUM;
}
bool QueueEmpty(sqQueue Q){
//判断是否为空队
if(Q.rear == Q.front)
return true;
return false;
}
void DeQueue(sqQueue &Q, int &u){
//队头元素出队并置为u
u = Q.base[Q.front];
Q.front = (Q.front + 1) % MAX_VERTEX_NUM;
}
//确定顶点在G中的位置
int LocateVex(AMGraph G, char v){
int i;
for (i = 0; i < G.vexnum; i++){
if (G.vexs[i] == v)break;
}
return i;
}
void CreateUDN(AMGraph& G) {
int i, j, k, w;
char va, vb;
printf("请输入无向网G的顶点数，边数\n");
scanf("%d %d", &G.vexnum, &G.arcnum);
for (i = 0; i < G.vexnum; i++)
for (j = 0; j < G.vexnum; j++) {
G.arcs[i][j] = MAXINT;
}
for(i=0;i<G.vexnum;i++){
for(j=0;j<G.vexnum;j++){
printf("%10d ",G.arcs[i][j]);
}
printf("\n");
}
printf("请输入%d个顶点的值：\n", G.vexnum);
fflush(stdin);
for (i = 0; i < G.vexnum; i++) scanf("%c", &G.vexs[i]);//空格的问题！！！！！
printf("请输入%d条边的权值、顶点1、顶点2(权值小于32767):\n", G.arcnum);
for (k = 0; k < G.arcnum; k++) {
scanf("%d%c%c", &w, &va, &vb);
i = LocateVex(G,va); j = LocateVex(G,vb);
G.arcs[i][j] = G.arcs[j][i] = w;
}
}
int FirstAdjVex(AMGraph G , int v){
//返回v的第一个邻接点
int i;
for(i = 0 ; i < G.vexnum ; ++i){
if(G.arcs[v][i] <= MAXINT && visited[i] == false)
return i;
}
return -1;
}
int NextAdjVex(AMGraph G , int u , int w){
//返回v相对于w的下一个邻接点
int i;
for(i = w ; i < G.vexnum ; ++i){
if(G.arcs[u][i] <= MAXINT && visited[i] == false)
return i;
}
return -1;
}
void BFS (AMGraph G, int v){
//按广度优先非递归遍历连通图G
sqQueue Q;
int u;
int w;
printf("%c",G.vexs[v]);
visited[v] = true; //访问第v个顶点，并置访问标志数组相应分量值为true
InitQueue(Q); //辅助队列Q初始化，置空
EnQueue(Q, v); //v进队
while(!QueueEmpty(Q)){ //队列非空
DeQueue(Q, u); //队头元素出队并置为u
for(w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)){
//依次检查u的所有邻接点w ，FirstAdjVex(G, u)表示u的第一个邻接点
//NextAdjVex(G, u, w)表示u相对于w的下一个邻接点，w≥0表示存在邻接点
if(!visited[w]){ //w为u的尚未访问的邻接顶点
printf("%c",G.vexs[w]); visited[w] = true; //访问w，并置访问标志数组相应分量值为true
EnQueue(Q, w); //w进队
}//if
}//for
}//while
}//BFS
int minimum(minside SZ, AMGraph G){//找lowcost最小的顶点下标
int i=0,j,k,min;
while(!SZ[i].lowCost) i++;//lowcost为0的顶点不再计算，因已在U集合中
min=SZ[i].lowCost;//第一个不为0的值
k=i;
for(j=i+1;j<G.vexnum;j++)
if(SZ[j].lowCost>0 && min>SZ[j].lowCost){//找到新的大于0的最小值
min=SZ[j].lowCost;
k=j;
}
return k;
}
void MiniSpanTree_PRIM(AMGraph G, char u){
int i,j,k;
minside closedge;
k=LocateVex(G,u);
for(j=0;j<G.vexnum;j++){
closedge[j].adjvex=u;
//strcpy(closedge[j].adjvex,u);
closedge[j].lowCost=G.arcs[k][j];
}
closedge[k].lowCost=0;
printf("最小代价生成树的各条边为：\n");
for(i=1;i<G.vexnum;i++){
k=minimum(closedge,G);
printf("%c-%c\n",closedge[k].adjvex,G.vexs[k]);
closedge[k].lowCost=0;
for(j=0;j<G.vexnum;j++){
if(G.arcs[k][j]<closedge[j].lowCost){
closedge[j].adjvex=G.vexs[k];
//strcpy(closedge[j].adjvex,G.vexs[k]);
closedge[j].lowCost=G.arcs[k][j];
}
}
}
}
void ShortPath_DIJ(AMGraph G,int v0 , PathMatrix &P , ShortPathTable &D){
int v,w,i,j,min;
int final[MAX_VERTEX_NUM];//辅助矩阵，1表示该顶点到v0的最短距离已出，0则为假
for(v=0;v<G.vexnum;v++){
final[v]=0; //辅助矩阵设初值
D[v]=G.arcs[v0][v];//存放v0到v的直接距离
for(w=0;w<G.vexnum;w++)
P[v][w]=0;//初始化，没有路径
if(D[v]<MAXINT)
P[v][v0]=P[v][v]=1;
}
D[v0]=0;
final[v0]=1;//v0顶点并入S集
for(i=1;i<G.vexnum;i++){//其余 G.vexnum-1个顶点
min=MAXINT;
for(w=0;w<G.vexnum;w++)//对所有顶点进行检查
if(final[w]==0 && D[w]<min){
v=w;
min=D[w];
}
final[v]=1;//将v并入S集
for(w=0;w<G.vexnum;w++)//根据新兵入伍的顶点，更新不在S集的顶点到V0的距离和路径数据
if(final[w]==0 && min<MAXINT && G.arcs[v][w]<MAXINT && (min+G.arcs[v][w]<D[w])){
D[w]=min+G.arcs[v][w];
for(j=0;j<G.vexnum;j++)
P[w][j]=P[v][j];
P[w][w]=1;
}
}
}
int main() {
int i, j;
int c;
AMGraph G;
CreateUDN(G);
for(i=0;i<G.vexnum;i++){
for(j=0;j<G.vexnum;j++){
printf("%10d ",G.arcs[i][j]);
}
printf("\n");
}
for(i=0;i<G.vexnum;i++){
visited[i]=false;
}
printf("请输入请输入遍历连通图的起始点：\n");
fflush(stdin);
scanf("%c",&c);
for(i=0;i<=G.vexnum;i++){
if(c == G.vexs[i])
break;
}
while(i >= G.vexnum){
printf("该点不存在，请重新输入！\n");
printf("请输入遍历连通图的起始点：\n");
scanf("%c",&c);
for(i = 0 ; i < G.vexnum ; ++i){
if(c == G.vexs[i])
break;
}
}
BFS(G , i);
j=0;
while(j<G.vexnum){
if(!visited[j]){
printf("\n这个网是非连通网\n");
return 0;
}
j++;
}
printf("\n这个网是连通网\n");
MiniSpanTree_PRIM(G, c) ;
PathMatrix p;
ShortPathTable d;
int v0;
char k;
printf("请输入想要计算距离的点的符号\n");
fflush(stdin);
scanf("%c",&k);
v0=LocateVex(G,k);
ShortPath_DIJ(G , v0, p, d);
printf("最短路径数组p[i][j]如下：\n");
for(i=0;i<G.vexnum;i++){
for(j=0;j<G.vexnum;j++)
printf("%2d",p[i][j]);
printf("\n");
}
printf("%c到各顶点的最短路径为：\n",G.vexs[v0]);
for(i=0;i<G.vexnum;i++)
if(i!=v0)
printf("%c-%c:%d\n",G.vexs[v0],G.vexs[i],d[i]);
return 0;
}
扫一扫
762
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
