目录
前言
一直在复习数据结构,针对邻接矩阵书上有个算法是输出两个顶点之间的一条简单路径,这个听着很简单,仔细想了想,这不就和二叉树里输出根节点到r所指节点路径一样吗,维持一个栈,找到r指针就把栈弹空。
类似的,对于U和V顶点也是一样的,维持一个栈,在图中找到V顶点,直接弹空栈。这个对于一条简单路径来说很容易。
但是课后题有一个是输出U到V的全部简单路径,一涉及到回溯我这种榆木脑袋就头疼,思前想后,也是维持一个栈?但是弹空后怎么回溯到上一个递归的节点呢?
不断的思考,在耿国华的老师的数据结构里给我了一点启发,他利用一个pre数组来记录路线,当从某个顶点vi找到其邻接顶点vj进行访问时,将pre[j]置为i,这样在退出搜索后,就能根据pre数组从顶点v追溯到顶点u,从而输出这条从u到v的简单路径。
不得不说,耿国华老师不亏是国家教学名师,确实很厉害,但是我这个榆木脑袋是实在想不出来这么巧妙的方法。
我借鉴了耿国华老师的算法,按照自己的理解写了一个我能看懂的深度优先找出顶点U到顶点V的所有简单路径。
我这里用path数组代替耿老师的pre数组,思路是一样的,耿老师的比较精练,我自己写的虽然繁琐,但胜在自己看的懂,能复现。
步骤如下
1 对于邻接矩阵
1.1 创建邻接矩阵
//求顶点位置函数
int LocateVertex(AdjMatrix* G, VertexData v) {
int j, k;
for (k = 0; k < G->vexnum; k++) {
if (G->vertex[k] == v) {
j = k;
break;
}
}
return j;
}
//建立有向网图的邻接矩阵表示
void CreateAdjMatrix(AdjMatrix* G) {
int i, j, k, weight;
VertexData v1, v2;
printf("输入顶点数和边数\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].adj = ZHENGWUQIONG;//正无穷#define ZHENGWUQIONG 65535
}
}
//顶点表
for (i = 0; i < G->vexnum; i++) {
G->vertex[i]='A' + i;
}
printf("输入边表\n");
for (k = 0; k < G->arcnum; k++) {
scanf(" %c, %c,%d", &v1, &v2, &weight);
i = LocateVertex(G, v1);
j = LocateVertex(G, v2);
G->arcs[i][j].adj = weight;
//加上下面这行这就创建无向图。
G->arcs[j][i].adj = G->arcs[i][j].adj;
}
}
1.2 初始化path数组和找到顶点U和顶点V的下标
代码如下:
LocateVertex函数
int LocateVertex(AdjMatrix* G, VertexData v) {
int j, k;
for (k = 0; k < G->vexnum; k++) {
if (G->vertex[k] == v) {
j = k;
break;
}
}
return j;
}
初始化path数组和输入vi,vj
int* path = (int*)malloc(sizeof(int) * G.vexnum);
printf("输入要查询的两个节点,英文逗号隔开\n");
char ci, cj;
scanf(" %c, %c", &ci, &cj);
int vi = LocateVertex(&G, ci);
int vj = LocateVertex(&G, cj);
for (int i = 0; i < MAX; i++) {
visited[i] = 0;
}
FindPath(G, vi, vj, path, -1);
free(path);
1.3 FindPath()函数
接下来就是进入FindPath函数中。
path数组用来存储路径,相当于栈,d为路径长度,初始为-1,相当于栈顶指针。
将vi设为已访问,d++后,将其放入path数组中,如果vi和vj一样说明找到了v,那么就将path数组输出,每次输出都把d–,表示已经退出,并且将visited数组设为未访问,方便下一个节点的访问,但是因为递归的原因,如果返回上一个节点,那么path数组也会变为上一个节点的模样,这样就完成了回溯,简直完美。
但是visited数组是全局变量,因此在每次进入节点前都要将当时的path数组里的元素设为都已经访问过,这样就避免节点从vi=0开始搜索又搜回去了的情况。
代码如下:
void FindPath(AdjMatrix g, int vi, int vj, int* path, int d) {//d为栈顶元素下标初始为-1;
int i;
++d;
//把vi放到path数组中
path[d] = vi;
//设置vi为已访问
visited[vi] = 1;
//如果找到vj
if (vi == vj) {
int len = d;
//弹空path数组
for (int j = 0; j <= len; j++) {
printf("%c ", g.vertex[path[j]]);
//退栈
d--;
//不要把根节点设为未访问,这样容易成死循环。
if (j != 0) {
visited[path[j]] = 0;
}
}
printf("\n");
return;
}
for (i = 0; i < g.vexnum; i++) {
//在进入节点前,要把path数组里的元素都设置已访问,避免因为上一次输出path数组清零visited数组而导致的循环访问。
for (int len = d; len >= 0; len--) {
visited[path[len]] = 1;
}
if (!visited[i] && g.arcs[vi][i].adj != ZHENGWUQIONG) {
FindPath(g, i, vj, path, d);
}
}
//如果循环完了还没找到就退栈并且设置没访问过。等于走了个死胡同然后退出。
if (i == g.vexnum) {
visited[vi] = 0;
d--;
}
}
1.4 测试结果
测试结果如下,找了个相当复杂的图。
找一个最复杂的A,D
芜湖,简直完美!
1.5 改进代码 感谢 @果冻的光滑 的指导和帮助!
- 感谢 @果冻的光滑对于代码的改进!
不难发现,本文FindPath代码中17到19行 和26到28行做的工作是完全互补的,但对于代码的简明性有着较大的影响,做出一点小小的改进则可以使代码更加简洁明了
- 再次感谢 @果冻的光滑提供的两种方案!
方案一
如果找到目的节点,只许将递归进入的节点标记位设为未访问,则递归返回后再搜寻即可实现相同的前节点的路径搜寻。若搜寻相邻节点都没有路径,本层vi的访问位置为未访问退出即可。
void FindPath(AdjMatrix g, int vi, int vj, int* path, int d) {//d为栈顶元素下标初始为-1;
int i;
++d;
//把vi放到path数组中
path[d] = vi;
//设置vi为已访问
visited[vi] = 1;
//如果找到vj
if (vi == vj) {
int len = d;
//弹空path数组
for (int j = 0; j <= len; j++) {
printf("%c ", g.vertex[path[j]]);
}
visited[vi] = 0;
printf("\n");
return;
}
for (i = 0; i < g.vexnum; i++) {
if (!visited[i] && g.arcs[vi][i].adj != ZHENGWUQIONG) {
FindPath(g, i, vj, path, d);
}
}
//如果循环完了还没找到就退栈并且设置没访问过。等于走了个死胡同然后退出。
visited[vi] = 0;
}
方案二
弹出path数组后,无需return返回上一层,path数组在输出后将已访问的节点访问位置为0,在进入下一节点前再将path数组中的值置为已访问,以实现相同的前节点的路径搜寻。
void FindPath(AdjMatrix g, int vi, int vj, int* path, int d) {//d为栈顶元素下标初始为-1;
int i;
++d;
//把vi放到path数组中
path[d] = vi;
//设置vi为已访问
visited[vi] = 1;
//如果找到vj
if (vi == vj) {
int len = d;
//弹空path数组
for (int j = 0; j <= len; j++) {
printf("%c ", g.vertex[path[j]]);
if (j != 0) {
visited[path[j]] = 0;
}
}
printf("\n");
}
for (i = 0; i < g.vexnum; i++) {
for (int len = d; len >= 0; len--) {
visited[path[len]] = 1;
}
if (!visited[i] && g.arcs[vi][i].adj != ZHENGWUQIONG) {
FindPath(g, i, vj, path, d);
}
}
//如果循环完了还没找到就退栈并且设置没访问过。等于走了个死胡同然后退出。
if (i == g.vexnum) {
visited[vi] = 0;
}
}
综合对比两种方案,个人感觉方案一更加简洁,方案二延续我的执着于动态展现该层的访问情况的visited的来回标记显得过于繁琐。
再次感谢 @果冻的光滑提供的两种方案!
对于邻接表的FindPath数组也是类似的思路。
2 对于邻接表
2.1 建立邻接表
这里用的尾插法建立的边表。
//求顶点位置函数
int LocateVertex(AdjList* G, VertexData v) {
int j, k;
for (k = 0; k < G->vexnum; k++) {
if (G->vertexlist[k].data == v) {
j = k;
break;
}
}
return j;
}
//创建邻接表
void CreateAdjList(AdjList* adjlist) {
int i, j, k, weight;
char vi, vj;
printf("请输入顶点数和边数:\n");
scanf("%d,%d", &adjlist->vexnum, &adjlist->arcnum);
for (i = 0; i < adjlist->vexnum; i++) {
adjlist->vertexlist[i].data = 'A' + i;
adjlist->vertexlist[i].firstarc = NULL;
}
printf("请输入弧的起点,终点和权值:\n");
for (k = 0; k < adjlist->arcnum; k++) {
scanf(" %c ,%c,%d", &vi, &vj, &weight);
ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));
p->adjvex = LocateVertex(adjlist, vj);
ArcNode* tmp = adjlist->vertexlist[LocateVertex(adjlist, vi)].firstarc;
if (tmp == NULL) {
p->nextarc = adjlist->vertexlist[LocateVertex(adjlist, vi)].firstarc;
adjlist->vertexlist[LocateVertex(adjlist, vi)].firstarc = p;
}
else {
while (tmp->nextarc != NULL) {
tmp = tmp->nextarc;
}
p->nextarc = tmp->nextarc;
tmp->nextarc = p;
}
//无向图有
ArcNode* s = (ArcNode*)malloc(sizeof(ArcNode));
s->adjvex = LocateVertex(adjlist, vi);
ArcNode* tmp2 = adjlist->vertexlist[LocateVertex(adjlist, vj)].firstarc;
if (tmp2 == NULL) {
s->nextarc = adjlist->vertexlist[LocateVertex(adjlist, vj)].firstarc;
adjlist->vertexlist[LocateVertex(adjlist, vj)].firstarc = s;
}
else {
while (tmp2->nextarc != NULL) {
tmp2 = tmp2->nextarc;
}
s->nextarc = tmp2->nextarc;
tmp2->nextarc = s;
}
}
}
2.2 初始化path数组和找到顶点U和顶点V的下标
几乎和1.2一模一样
int* path = (int*)malloc(sizeof(int) * G.vexnum);
printf("输入要查询的两个节点,英文逗号隔开\n");
char ci, cj;
scanf(" %c, %c", &ci, &cj);
int vi = LocateVertex(&G, ci);
int vj = LocateVertex(&G, cj);
for (int i = 0; i < MAX; i++) {
visited[i] = 0;
}
FindPath(G, vi, vj, path, -1);
free(path);
2.3 FindPath()函数
和邻接矩阵的方法也是大同小异
//深度优先找出顶点u和顶点v的简单路径
void FindPath(AdjList g, int vi, int vj, int* path, int d) {
visited[vi] = 1;
d++;
path[d] = vi;
if (vi == vj) {
int i;
for (i = 0; i <= d; i++) {
printf("%c ", g.vertexlist[path[i]].data);
if (i != 0) {
visited[path[i]] = 0;
}
}
printf("\n");
return;
}
ArcNode* p = g.vertexlist[vi].firstarc;
while (p != NULL) {
for (int len = d; len >= 0; len--) {
visited[path[len]] = 1;
}
if (!visited[p->adjvex]) {
FindPath(g, p->adjvex, vj, path, d);
}
p = p->nextarc;
}
if (p == NULL) {
visited[vi] = 0;
d--;
}
}
2.4 测试结果
还是这个图
想必是没有问题的。
perfect!
总结
这个算法虽然有点笨,但是我的榆木脑袋能理解,个人感觉很成功!