第十二周 项目4 利用遍历思想求解图问题--深度优先遍历

最新推荐文章于 2023-06-24 18:41:25 发布
最新推荐文章于 2023-06-24 18:41:25 发布
阅读量296 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S1E2L3/article/details/53317398
版权

问题描述：

/* 
copyright （t） 2016，烟台大学计算机学院 
*All rights reserved. 
*文件名称：11.cpp 
*作者：白晓娟
*完成日期：2016年11月24日 
*版本号：v1.0 
*问题描述：假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。  
　　（1）设计一个算法，判断顶点u到v是否有简单路径  
　　（2）设计一个算法输出图G中从顶点u到v的一条简单路径（设计测试图时，保证图G中从顶点u到v至少有一条简单路径）。  
　　（3）输出从顶点u到v的所有简单路径。  
　　（4）输出图G中从顶点u到v的长度为s的所有简单路径。  
　　（5）求图中通过某顶点k的所有简单回路（若存在）  
*输入描述：根据问题情境而定，有的直接调用确定参数的函数，有的则输入顶点编号 
*程序输出：测试结果 
*/

代码：

graph.h：

//graph.h
#include <stdio.h>  
#define MAXV 100                   //定义最大顶点数100  
#define limitless 9999             //处理“无穷大”  
typedef int InfoType;              //定义顶点与边的相关信息  
typedef int Vertex;  
  
typedef struct                     //定义顶点类型  
{  
    int no;                        //顶点编号  
    InfoType info;                 //顶点其他信息  
} VertexType;  
typedef struct                     //定义图邻接矩阵类型  
{  
    int edges[MAXV][MAXV];         //邻接矩阵边数组  
    int n;                         //顶点数  
    int e;                         //边数  
    VertexType vexs[MAXV];         //存放顶点信息  
} MGraph;  
  
typedef struct ANode               //定义边节点类型  
{  
    int adjvex;                    //该边终点编号  
    struct ANode *nextarc;         //指向下一条边的指针  
    InfoType info;                 //该边相关信息  
} ArcNode;  
typedef struct VNode               //定义邻接表头节点类型  
{  
    Vertex data;                   //顶点信息  
    ArcNode *firstarc;             //指向第一条边的指针  
} VNode;  
typedef VNode AdjList[MAXV];       //AdjList: 邻接表类型  
typedef struct                     //定义图邻接表类型  
{  
    AdjList adjlist;               //邻接表  
    int n;                         //图中顶点数  
    int e;                         //图中边数  
} ALGraph;  
  
void ArrayToMat(int *Arr, int n, MGraph &g);         //用普通数组构造图的邻接矩阵  
void ArrayToList(int *Arr, int n, ALGraph *&G);      //用普通数组构造图的邻接表  
void MatToList(MGraph g,ALGraph *&G);                //将邻接矩阵g转换成邻接表G  
void ListToMat(ALGraph *G,MGraph &g);                //将邻接表G转换成邻接矩阵g  
void DispMat(MGraph g);                              //输出邻接矩阵g  
void DispAdj(ALGraph *G);                            //输出邻接表G  


//graph.cpp



#include <malloc.h>  
#include "graph.h"  
//几点说明：  
//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图  
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）  
//      n - 矩阵的阶数  
//      g - 要构造出来的邻接矩阵数据结构  
void ArrayToMat(int *Arr, int n, MGraph &g)         //用普通数组构造图的邻接矩阵  
{  
    int i,j;  
    int edgenum=0;                                  //边数初始化为0  
    g.n=n;  
    for(i=0;i<g.n;i++)  
    {  
        for(j=0;j<g.n;j++)  
        {  
            g.edges[i][j]=Arr[i*n+j];               //计算存储位置  
            if(g.edges[i][j]!=0 && g.edges[i][j]!=limitless)  
                edgenum++;  
        }  
    }  
    g.e=edgenum;  
}  
void ArrayToList(int *Arr, int n, ALGraph *&G)      //用普通数组构造图的邻接表  
{  
    int i,j;  
    int edgenum=0;                                  //边数初始化为0  
    ArcNode *p;                                     //后续操作中创建的新节点  
    G=(ALGraph *)malloc(sizeof(ALGraph));  
    G->n=n;  
    for(i=0;i<n;i++)                                //邻接表所有头节点指针域置初值  
        G->adjlist[i].firstarc=NULL;  
    for(i=0;i<n;i++)                                //遍历邻接矩阵中的每个元素  
    {  
        for(j=n-1;j>=0;j--)  
        {  
            if(Arr[i*n+j]!=0)  
            {  
                p=(ArcNode *)malloc(sizeof(ArcNode)); //创建节点*p  
                p->adjvex=j;  
                p->info=Arr[i*n+j];  
                p->nextarc=G->adjlist[i].firstarc;    //头插法插入*p  
                G->adjlist[i].firstarc=p;             //指向第一条边的指针指向*p  
            }  
        }  
    }  
    G->e=edgenum;  
}  
void MatToList(MGraph g,ALGraph *&G)                //将邻接矩阵g转换成邻接表G  
{  
    int i,j;  
    ArcNode *p;  
    G=(ALGraph *)malloc(sizeof(ALGraph));  
    for(i=0;i<g.n;i++)                              //给邻接表所有头节点的指针域置初值  
        G->adjlist[i].firstarc=NULL;  
    for(i=0;i<g.n;i++)                              //遍历邻接矩阵中的每个元素  
    {  
        for(j=g.n-1;j>=0;j--)  
        {  
            if(g.edges[i][j]!=0)  
            {  
                p=(ArcNode *)malloc(sizeof(ArcNode)); //创建一个节点*p  
                p->adjvex=j;                          //终点编号赋值  
                p->nextarc=G->adjlist[i].firstarc;    //头插法插入节点*p  
                G->adjlist[i].firstarc=p;             //连接  
            }  
        }  
    }  
    G->n=g.n;  
    G->e=g.e;  
}  
void ListToMat(ALGraph *G,MGraph &g)                //将邻接表G转换成邻接矩阵g  
{  
    //前提要求：g的实参调用前已经初始化为全0  
    int i;  
    ArcNode *p;  
    for(i=0;i<G->n;i++)  
    {  
        p=G->adjlist[i].firstarc;                   //*p指向每个顶点的第一条边  
        while(p!=NULL)                              //依次遍历  
        {  
            g.edges[i][p->adjvex]=1;                //p不为空指针时对应矩阵元素赋值1  
            p=p->nextarc;                           //*p指向下一条边  
        }  
    }  
    g.n=G->n;  
    g.e=G->e;  
}  
void DispMat(MGraph g)                              //输出邻接矩阵g  
{  
    int i,j;  
    for(i=0;i<g.n;i++)  
    {  
        for(j=0;j<g.n;j++)  
            if(g.edges[i][j]==limitless)  
                printf("%3s","∞");  
            else  
                printf("%3d",g.edges[i][j]);  
        printf("\n");  
    }  
}  
void DispAdj(ALGraph *G)                            //输出邻接表G  
{  
    int i;  
    ArcNode *p;  
    for (i=0; i<G->n; i++)  
    {  
        p=G->adjlist[i].firstarc;  
        printf("%3d: ",i);  
        while (p!=NULL)  
        {  
            printf("-->%d/%d ",p->adjvex,p->info);  
            p=p->nextarc;  
        }  
        printf("\n");  
    }  
}

（1）判断简单路径是否存在

main.cpp：

//main.cpp

#include <stdio.h>  
#include "graph.h"  
int visited[MAXV];                                   //定义visited[] 全局数组，记录顶点访问情况  
void ExistPath(ALGraph *G,int u,int v,bool &has)     //has表示从顶点u到顶点v有路径，初值设为false  
{  
    int w;  
    ArcNode *p;  
    visited[u]=1;                                    //置已访问标记  
    if(u==v)                                         //到一条路径时，结束算法  
    {  
        has=true;  
        return;  
    }  
    p=G->adjlist[u].firstarc;                        //p指向顶点u的第一个邻接点  
    while(p!=NULL)  
    {  
        w=p->adjvex;                                 //w为顶点u的相邻顶点  
        if(visited[w]==0)                            //若w顶点未被访问，递归访问它  
            ExistPath(G,w,v,has);  
        p=p->nextarc;                                //p指向顶点u的下一个邻接点  
    }  
}  
void HasPath(ALGraph *G,int u,int v)  
{  
    int i;  
    bool flag=false;  
    for(i=0;i<G->n;i++)                              //初始化  
        visited[i]=0;  
    ExistPath(G,u,v,flag);  
    if(flag)  
        printf("从顶点%d到顶点%d有简单路径\n",u,v);  
    else  
        printf("从顶点%d到顶点%d无简单路径\n",u,v);  
}  
int main()  
{  
    ALGraph *G;  
    int A[5][5]=  
    {  
        {0,0,1,0,0},  
        {0,0,0,1,0},  
        {1,0,1,0,1},  
        {0,0,0,0,1},  
        {1,0,1,1,0},  
    };  
    ArrayToList(A[0],5,G);  
    HasPath(G,1,0);  
    HasPath(G,4,1);  
    return 0;  
}

运行结果：


（2）输出从顶点u到顶点v的一条简单路径

main.cpp：


//main.cpp

#include <stdio.h>  
#include "graph.h"  
int visited[MAXV];                                            //定义visited[] 全局数组，记录顶点访问情况  
int path[MAXV];                                               //定义path[] 全局数组，存储路径上经过的顶点  
void FindaPath(ALGraph *G,int u,int v,int path[],int d)       //寻找一条简单路径，d初值为-1  
{  
    int w,i;  
    ArcNode *p;  
    visited[u]=1;  
    d++,path[d]=u;                                            //路径长度d增1，顶点u加入路径中  
    if(u==v)                                                  //当前顶点为终点时，输出一条简单路径  
    {  
        printf("一条简单路径为：");  
        for(i=0;i<=d;i++)  
            printf("%d ",path[i]);  
        printf("\n");  
        return;  
    }  
    p=G->adjlist[u].firstarc;                                 //p指向顶点u的第一个相邻点  
    while(p!=NULL)  
    {  
        w=p->adjvex;                                          //相邻点编号为w  
        if(visited[w]==0)  
            FindaPath(G,w,v,path,d);  
        p=p->nextarc;                                         //p指向顶点u的下一个相邻点  
    }  
}  
int main()  
{  
    ALGraph *G;  
    int A[5][5]=  
    {  
        {0,0,1,0,0},  
        {0,0,0,1,0},  
        {1,0,1,0,1},  
        {0,0,0,0,1},  
        {1,0,1,1,0},  

    };  
    ArrayToList(A[0],5,G);  
    FindaPath(G,1,0,path,-1);  
    return 0;  
}

运行结果：



（3）输出从顶点u到顶点v的所有简单路径

main.cpp：

#include <stdio.h>  
#include "graph.h"  
int visited[MAXV];                                            //定义visited[] 全局数组，记录顶点访问情况  
int path[MAXV];                                               //定义path[] 全局数组，存储路径上经过的顶点  
void FindPath(ALGraph *G,int u,int v,int path[],int d)        //寻找所有简单路径，d初值为-1  
{  
    int w,i;  
    ArcNode *p;  
    visited[u]=1;  
    d++,path[d]=u;                                            //路径长度d增1，顶点u加入路径中  
    if(u==v && d>=1)                                          //找到一条路径则输出  
    {  
        for(i=0;i<=d;i++)  
            printf("%d ",path[i]);  
        printf("\n");  
    }  
    p=G->adjlist[u].firstarc;                                 //p指向顶点u的第一个相邻点  
    while(p!=NULL)  
    {  
        w=p->adjvex;                                          //相邻点编号为w  
        if(visited[w]==0)  
            FindPath(G,w,v,path,d);  
        p=p->nextarc;                                         //p指向顶点u的下一个相邻点  
    }  
    visited[u]=0;                                             //恢复环境，使该顶点可重新使用  
}  
int main()  
{  
    ALGraph *G;  
    int u,v;  
    int A[5][5]=  
    {  
        {0,0,1,0,0},  
        {0,0,0,1,0},  
        {1,0,1,0,1},  
        {0,0,0,0,1},  
        {1,0,1,1,0},  
    };  
    ArrayToList(A[0],5,G);  
    while(scanf("%d %d",&u,&v)!=EOF)  
    {  
        printf("从顶点%d到顶点%d的所有简单路径为：\n",u,v);  
        FindPath(G,u,v,path,-1);  
    }  
    return 0;  
}

运行结果：


（4）输出从顶点u到顶点v的长度为s的所有简单路径

main.cpp：


//main.cpp

#include <stdio.h>  
#include "graph.h"  
int visited[MAXV];                                            //定义visited[] 全局数组，记录顶点访问情况  
int path[MAXV];                                               //定义path[] 全局数组，存储路径上经过的顶点  
void PathAll(ALGraph *G,int u,int v,int s,int path[],int d)   //寻找所有长度为s的简单路径，d初值为-1  
{  
    int w,i;  
    ArcNode *p;  
    visited[u]=1;  
    d++,path[d]=u;                                            //路径长度d增1，顶点u加入路径中  
    if(u==v && d==s)                                          //找到一条路径则输出  
    {  
        for(i=0;i<=d;i++)  
            printf("%d ",path[i]);  
        printf("\n");  
    }  
    p=G->adjlist[u].firstarc;                                 //p指向顶点u的第一个相邻点  
    while(p!=NULL)  
    {  
        w=p->adjvex;                                          //相邻点编号为w  
        if(visited[w]==0)  
            PathAll(G,w,v,s,path,d);  
        p=p->nextarc;                                         //p指向顶点u的下一个相邻点  
    }  
    visited[u]=0;                                             //恢复环境，使该顶点可重新使用  
}  
int main()  
{  
    ALGraph *G;  
    int u,v,s;  
    int A[5][5]=  
    {  
        {0,0,1,0,0},  
        {0,0,0,1,0},  
        {1,0,1,0,1},  
        {0,0,0,0,1},  
        {1,0,1,1,0},  
    };  
    ArrayToList(A[0],5,G);  
    while(scanf("%d %d %d",&u,&v,&s)!=EOF)  
    {  
        printf("从顶点%d到顶点%d的所有长度为%d的简单路径为：\n",u,v,s);  
        PathAll(G,u,v,s,path,-1);  
    }  
    return 0;  
}
运行结果：









S1E2L3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深度优先遍历访问的边集合_无向图深度优先遍历(DFS)和广度优先遍历(BFS)算法...
weixin_31049801的博客
12-23 1173
定义深度优先遍历(1)从图中某个初始顶点v出发，首先访问初始顶点v。(2)选择一个与顶点v相邻且没被访问过的顶点w，再从w出发进行深度优先搜索，直到图中与当前顶点v邻接的所有顶点都被访问过为止。(3) 利用递归实现，简单但是不好理解，时间复杂度 O(n+e)。广度优先遍历(1)访问初始点v，接着访问v的所有未被访问过的邻接点v1，v2，…，vt。(2)按照v1，v2，…，vt的次序，访问每一个顶点...
深度优先遍历DFS
m0_59782507的博客
09-07 302
首先，图的深度优先遍历是由起始节点出发，开始递归地访问它的一个邻接节点，直到最后的结点没有邻接节点。 这里用邻接表的方式表现图的深度优先遍历 再回顾一下邻接表的定义 typedef struct ArcNode { //定义边结点 int adjvex;//该边所指向的顶点 struct ArcNode *nextarc;//指向下一条边的指针 double info;//这里可以用来存储边的信息，例如边的权 }ArcNode; typedef struct {//定义顶点 int dat
图的遍历算法之深度优先遍历（DFS）(C++)
smart_jackli的博客
11-18 6364
图的深度优先遍历算法实现
图的深度优先遍历
清影的博客
06-24 65
图的深度优先遍历
JavaScript遍历求解数独问题的主要思路小结
10-22
JavaScript遍历求解数独问题的核心在于通过深度优先搜索（DFS）策略，结合有效的状态判定，逐步填充数独网格。以下是对主要思路的详细解析： 首先，了解数独的规则：一个9x9的宫格被划分为9个3x3的小宫格，玩家需要...
3、省选＋NOI-第三部分 树上问题_2020.08.27.pdf
11-25
- DFS（深度优先搜索）：包括前序、中序和后序遍历。 - BFS（广度优先搜索）：利用队列实现，常用于寻找最短路径。 3. **树的直径** - 树的直径是指树中任意两个节点间的最长路径的长度，可以使用LCA（最近公共...
基础算法 第5章 搜索与回溯算法(C++版)-2020.12.23.pdf
12-23
回溯算法是一种基于深度优先搜索的策略，其核心思想是在解决问题的过程中，尝试所有可能的路径，当发现当前路径无法导致正确解时，会回溯到上一步甚至更早的决策点，尝试其他路径。这种“试错”和“撤销”的过程，...
数据结构2图的遍历.ppt
09-28
【数据结构2图的遍历】是关于图论在计算机科学中的一个重要概念，主要涉及到两种主要的遍历方法：深度优先搜索（Depth First Search, DFS）和广度优先搜索（Breadth First Search, BFS）。这两种遍历方法主要用于在...
考试类精品--王道考研机试指南(第二版) 习题代码.zip
最新发布
02-06
例如，二叉树的遍历、图的深度优先搜索和广度优先搜索等。 2. **算法分析**：算法是解决问题的关键，包括排序算法（冒泡排序、快速排序、归并排序等）、查找算法（线性查找、二分查找）、动态规划、贪心算法等。...
图的深度优先搜索遍历
m0_47575628的博客
10-11 122
int visited[maxsize]={0}; //是否访问标记，访问过置为1 void DFS(AGraph *G,int v) //图和起点标号 { ArcNode *p; //边结点指针 visited[v]=1; //置为已访问 cout<<G->adjlist[v].data; //输出该节点的数据 p=...
C语言实现图的深度优先遍历和广度优先遍历
热门推荐
BEICHENx1的博客
11-28 1万+
图的深度优先遍历和广度优先遍历图的遍历深度优先遍历广度优先遍历 图的遍历 从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历 图的遍历方法有两种，一种叫深度优先遍历（DFS），另一种叫广度优先遍历（BFS）。 深度优先遍历 深度优先遍历的过程是从图中的某个初始点v出发，首先访问初始点v，然后选择一个与顶点v相邻且没被...
第十二周项目3-图遍历算法实现（1-深度优先遍历）
YangCJ_的博客
12-15 546
/*    copyright （t） 2016，烟台大学计算机学院    *All rights reserved.    *文件名称：1.cpp    *作者：车金阳   *完成日期：2016年12月15日    *版本号：v1.0    *问题描述：实现图遍历算法，输出如下图结构的深度优先(DFS)遍历序列。    *输入描述：无    *程序输出：测试结
深度优先搜索DFS递归实现图的遍历
小鱼的小窝
12-12 1053
DFS遍历图
第十二周项目4-利用遍历思想求解图问题（1-深度优先遍历）
cr496352127的博客
11-18 457
问题： /* copyright （t） 2016，烟台大学计算机学院 *All rights reserved. *文件名称：1.cpp *作者：常锐 *完成日期：2016年11月18日 *版本号：v1.0 *问题描述：假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 　　（1）设计一个算法，判断顶
实验题6.2 实现图的遍历算法
weixin_44745291的博客
11-07 1577
【实验目的】 （1）巩固所学的有关图的基本知识； （2）熟练掌握图的存储结构； （3）熟练掌握图的两种遍历算法。 【实验准备】 （1）阅读教材中图的遍历相关内容； （2）熟悉图的遍历算法。 【实验要求】 （1）采用函数调用的方式完成； （2）文件funp6-2.cpp的作用是完成图的深度优先遍历DFS和广度优先遍历BFS操作； （3）实验提交必须有完整正确的程序以及程序运行结果的截图。 【实验内容】 编写一个程序，实现下图的遍历算法。（深度优先遍历DFS和广度优先遍历BFS） .
数据结构期末考题
m0_53387935的博客
12-05 657
1.头插法创建学生数据类型单链表 #include <stdio.h> #include<stdlib.h> #include<string.h> /* 定义学生数据类型STUDENT */ typedef struct date { int year; int month; int day; }DATE; typedef struct student { int num; char name[20]; char
图-----深度优先遍历（DFS)
weixin_39916039的博客
08-18 291
原理： DFS是从每一个顶点开始的深度优先遍历，结果都是对该分支路径深入遍历到不能再深入为止，且每个顶点只能被访问一次。 具体实现是： 从图G中某个顶点v出发，先访问该结点，然后依次沿着未访问过的v的邻接顶点进行深度优先遍历，直到图G中和顶点v之间有相连路径的其他顶点都被访问过为止；此时，如果图G中还有其他顶点未被访问过，则从这些顶点中任选一个作为起始顶点，重复上述过程，直到图G中所有顶点都...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值