博客围绕作业五实验一展开，要求建立含6个结点的有向图并求顶点v0到其它顶点的最短路径。书中迪杰斯特拉算法只能求直接前驱顶点和最短路径长度，作者完善该算法使其能求出所有前驱结点，还介绍了typedef与结构结合使用及struct的不同用法，最后附上完整代码。
作业五实验一，要求建立一个建立一个包含6个结点的有向图，并求顶点v0到其它的最短路径。
书中对应的算法是迪杰斯特拉算法，但我发现书中算法只能求出各顶点的直接前驱顶点和最短路径长度，无法直接求出整条路径，所以我自己完善了一下。
首先是定义结构体
typedef struct graph //邻接矩阵
{
char vexs[ MAX ]; //顶点集合
int vexnum; //顶点数
int edgnum; //边数
int matrix[MAX][MAX]; //邻接矩阵
}Graph,*pGragh;
typedef struct edgedata
{
char start; //边的起点
char end; //边的终点
int weight; //边的权重
}Edata,*pEdata;
typedef struct dingdian
{
int vex; //该顶点下标
struct dingdian *prevex; //指向该顶点的前驱顶点的下标
}prevexs,*link;
第一个和第二个结构体是照着书写的，第一个是表示邻接矩阵，第二个是表示边。
关键是第三个结构体，是我自己写的，是一个类似于链表数组的结构。每个链表的头节点的vex表示该条最短路径的终点，而从第二个结点开始，vex则表示从起点到终点的最短路径上的顶点。（按顺序排列）
笔记
- typedef与结构结合使用
例子：
typedef struct tagMyStruct
{
int iNum;
long lLength;
} MyStruct;
这语句实际上完成两个操作：
- 定义一个新的结构类型
struct tagMyStruct
{
int iNum;
long lLength;
};
分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。
我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。
- typedef为这个新的结构起了一个名字，叫MyStruct。
typedef struct tagMyStruct MyStruct;
因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。
分析：
C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。
根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。
解决方法：
1)、
typedef struct tagNode
{
char *pItem;
struct tagNode *pNext;
} *pNode;
2)、
typedef struct tagNode *pNode;
struct tagNode
{
char *pItem;
pNode pNext;
};
注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。
补充：
struct在代码中常见两种形式：
struct A
{
//...
};
struct
{
//...
} A;
这其实是两个完全不同的用法：
前者叫做“结构体类型定义”，意思是：定义{}中的结构为一个名称是“A”的结构体。
这种用法在typedef中一般是：
typedef struct tagA //故意给一个不同的名字，作为结构体的实名
{
//...
} A; //结构体的别名
后者是结构体变量定义，意思是：以{}中的结构，定义一个名称为"A"的变量。这里的结构体称为匿名结构体，是无法被直接引用的。
也可以通过typedef为匿名结构体创建一个别名，从而使得它可以被引用：
typedef struct
{
//...
} A; //定义匿名结构体的别名为A
接下来就是这道题的解体关键，迪杰斯特拉算法。
void dijkstra(Graph G, int vs, int prev[], int dist[])
{
int i, j, k;
int min;
int temp;
int flag[MAX]; //标志位，若flag[i]==1,表明已经找到最短路径
for (i = 0;i < G.vexnum;i++)//初始化
{
flag[i] = 0;
prev[i] = vs;
dist[i] = G.matrix[vs][i];
}
flag[vs] = 1;
dist[vs] = 0; //对顶点vs自身进行初始化
for (i = 1;i < G.vexnum;i++) //遍历G.vexnum-1次，每次找出一个顶点的最短路径
{
min = INF;
for (j = 0;j < G.vexnum;j++)
{
if (flag[j] == 0 && dist[j] < min)
{
min = dist[j];
k = j;
}
} //表明第k个顶点已找到最短路径
flag[k] = 1;
for (j = 0;j < G.vexnum;j++)
{
temp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j]));//防止移出
if (flag[j] == 0 && temp < dist[j])
{
dist[j] = temp;
prev[j]=k;
}
}
}
}
这个算法的核心思想就是贪心算法。
先自己在脑中建立两个抽象数组S和D，S为已求得最短路径的顶点的集合，D为未求得最短路径的顶点的集合。如何表现顶点在S或在D中呢？这里就需要一个标志位flag[i]。若flag[i]==1，则表示该顶点i已找到最短路径，加入数组S；若flag[i]==0,则表示该顶点还未找到最短路径，加入数组D。
具体步骤：
进行G.vexnum-1次循环（自己没必要找最短路径，所以少一次），在循环中找出flag[i]==0的 顶点i中，最短路径数值最小的顶点i，把它的flag[i]改成1,若其他顶点的最短路径通过该顶点后，能缩短，则对其进行更新。
找到最短路径的方法：设置一个最小值MIN，初始值为INF。再进行G.vexnum次循环，在每次循环中，比较每个顶点的最短距离dist[i],若dist[i]<min且flag[i]==0,则min=dist[i]。
但在这个问题中，要求是求出路径，但这个算法只能求出每个顶点的直接前驱结点，没有办法找出所有前驱结点，所以鄙人在这个算法上进行了完善，使其能求出所有前驱结点。
完善的内容就是：设置一个循环，循环的内容就是找直接前驱结点的直接前驱结点，直到找到的前驱结点为起点为止。
该操作的具体实现方式：
因为不知道最短路径上会经过多少个顶点，所以设置一个链表来存储最短路径上的顶点。
然后利用头插法逐个找出直接前驱结点。（利用头插法可以按顺序的输出最短路径上的顶点）
完善后：
void print(int vs, Graph G, int prev[], int i,int dist[])
{
link a;
link p;
int j;
a = (link)malloc(sizeof(prevexs));
a->vex = i;
j = i;
a->prevex = NULL;
while (a->vex != vs)
{
p = (link)malloc(sizeof(prevexs));
p->vex = a->vex;
a->vex = prev[j];
j = prev[j];
p->prevex = a->prevex;
a->prevex = p;
}
printf("%c到%c的最短路径为：", G.vexs[vs], G.vexs[i]);
p = a;
while (p->prevex != NULL)
{
printf("%c", G.vexs[p->vex]);
p = p->prevex;
}
printf("%c", G.vexs[i]);
printf("最短路径长度为：%d", dist[i]);
printf("\n");
}
void dijkstra(Graph G, int vs, int prev[], int dist[])
{
int i, j, k;
int min;
int temp;
int flag[MAX]; //标志位，若flag[i]==1,表明已经找到最短路径
for (i = 0;i < G.vexnum;i++)//初始化
{
flag[i] = 0;
prev[i] = vs;
dist[i] = G.matrix[vs][i];
}
flag[vs] = 1;
dist[vs] = 0; //对顶点vs自身进行初始化
for (i = 1;i < G.vexnum;i++) //遍历G.vexnum-1次，每次找出一个顶点的最短路径
{
min = INF;
for (j = 0;j < G.vexnum;j++)
{
if (flag[j] == 0 && dist[j] < min)
{
min = dist[j];
k = j;
}
} //表明第k个顶点已找到最短路径
flag[k] = 1;
for (j = 0;j < G.vexnum;j++)
{
temp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j]));//防止移出
if (flag[j] == 0 && temp < dist[j])
{
dist[j] = temp;
prev[j]=k;
}
}
}
printf("图中各顶点到顶点%c的最短路径为：\n",G.vexs[vs]);
for (i = 0;i < MAX;i++)
{
if (flag[i] == 0)
{
printf("顶点%c到顶点%c无最短路径\n",G.vexs[vs],G.vexs[i]);
}
else
print(vs, G, prev, i,dist);
}
}
在这里要有一个需要注意的点：
在初始化时，每个顶点的直接前驱结点不应该设置成0，而是应该设置成起点的下标vs。
这是因为当某一个顶点的前驱结点就是该起点时，该顶点的prev[i]值不会修改，会保持为默认值。
若此时把默认的直接前驱结点设置成0，则在寻找最短路径上的顶点时，无法找到起点下标vs，造成死循环。
最后附上完整代码：
#include "pch.h"
#include <iostream>
#define MAX 6
#define INF 10000
typedef int Status;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFESIBLE -1
#define OVERFLOW -2
// 表示函数的状态
typedef struct graph //邻接矩阵
{
char vexs[ MAX ]; //顶点集合
int vexnum; //顶点数
int edgnum; //边数
int matrix[MAX][MAX]; //邻接矩阵
}Graph,*pGragh;
typedef struct edgedata
{
char start; //边的起点
char end; //边的终点
int weight; //边的权重
}Edata,*pEdata;
typedef struct dingdian
{
int vex; //该顶点下标
struct dingdian *prevex; //指向该顶点的前驱顶点的下标
}prevexs,*link;
void InitGraph(pGragh G, pEdata p) //对邻接矩阵进行初始化
{
int i, j;
i = 0;
j = 0;
while (G->vexs[i] != p->start&&i <= MAX)
{
i++;
}
if (MAX == i)
{
puts("找不到该起点");
exit(0);
}
while (G->vexs[j]!=p->end&&j<=MAX)
{
j++;
}
if (MAX == j)
{
puts("找不到该边的终点");
exit(0);
}
G->matrix[i][j] = p->weight;
}
void print(int vs, Graph G, int prev[], int i,int dist[])
{
link a;
link p;
int j;
a = (link)malloc(sizeof(prevexs));
a->vex = i;
j = i;
a->prevex = NULL;
while (a->vex != vs)
{
p = (link)malloc(sizeof(prevexs));
p->vex = a->vex;
a->vex = prev[j];
j = prev[j];
p->prevex = a->prevex;
a->prevex = p;
}
printf("%c到%c的最短路径为：", G.vexs[vs], G.vexs[i]);
p = a;
while (p->prevex != NULL)
{
printf("%c", G.vexs[p->vex]);
p = p->prevex;
}
printf("%c", G.vexs[i]);
printf("最短路径长度为：%d", dist[i]);
printf("\n");
}
void dijkstra(Graph G, int vs, int prev[], int dist[])
{
int i, j, k;
int min;
int temp;
int flag[MAX]; //标志位，若flag[i]==1,表明已经找到最短路径
for (i = 0;i < G.vexnum;i++)//初始化
{
flag[i] = 0;
prev[i] = vs;
dist[i] = G.matrix[vs][i];
}
flag[vs] = 1;
dist[vs] = 0; //对顶点vs自身进行初始化
for (i = 1;i < G.vexnum;i++) //遍历G.vexnum-1次，每次找出一个顶点的最短路径
{
min = INF;
for (j = 0;j < G.vexnum;j++)
{
if (flag[j] == 0 && dist[j] < min)
{
min = dist[j];
k = j;
}
} //表明第k个顶点已找到最短路径
flag[k] = 1;
for (j = 0;j < G.vexnum;j++)
{
temp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j]));//防止移出
if (flag[j] == 0 && temp < dist[j])
{
dist[j] = temp;
prev[j]=k;
}
}
}
printf("图中各顶点到顶点%c的最短路径为：\n",G.vexs[vs]);
for (i = 0;i < MAX;i++)
{
if (flag[i] == 0)
{
printf("顶点%c到顶点%c无最短路径\n",G.vexs[vs],G.vexs[i]);
}
else
print(vs, G, prev, i,dist);
}
}
int main()
{
pGragh G;
pEdata E,p;
int i,j,k;
char ch;
int prev[MAX];
int dist[MAX];
k = 0;
G = (pGragh)malloc(sizeof(Graph));
G->vexnum = MAX;
for (int a = 0;a < MAX;a++)
{
for (int b = 0;b < MAX;b++)
G->matrix[a][b] = INF;
}
puts("请输入各顶点");
for (i = 0;i < MAX;i++)
{
scanf(" %c", &G->vexs[i]);
}
puts("请输入边的个数");
scanf("%d", &j);
E = (pEdata)malloc(j * sizeof(Edata));
p = E;
puts("请输入各条边的信息");
for (i = 0;i < j;i++, p++)
{
puts("请输入该边的起点");
scanf(" %c", &p->start);
puts("请输入该边的终点");
scanf( " %c", &p->end);
puts("请输入该边的权值");
scanf("%d", &p->weight);
InitGraph(G, p);
}
for (int a = 0;a < MAX;a++)
{
for (int b = 0;b < MAX;b++)
printf("%5d\t", (G->matrix[a][b]));
printf("\n");
}
puts("请输入你想要寻找最短路径的顶点");
scanf(" %c", &ch);
while (G->vexs[k]!=ch&&k<=MAX)
{
if (MAX == k)
{
puts("没有找到该顶点");
}
k++;
}
if (k != MAX)
{
dijkstra(*G, k, prev, dist);
}
}
扫一扫
2769
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
