如何实现深度优先遍历(DFS)

DFS实现步骤如下:

①访问顶点V,并标记V已经访问

②查找V的第一个邻接顶点w

③若W存在,则继续执行,否则算法结束

④若W未被访问,则使用DFS递归访问w

⑤查找V的下一个邻接节点,并记为W,转到步骤③

对上图进行DFS,则访问顺序为

A B D C E

使用伪代码如下:

Vector <int>  G[maxn]
int vis[maxn]

void  dfs(int u)
{
    vis[u]=1;  //设置为已经访问
    int d=G[u].Size()//得到顶点u的所有邻接节点,个数为d
    for(int i=0;i<d;i++)
    {
     int v=G[u][i];//扫描所有的邻接顶点,如果没访问过,则DFS访问这个顶点
     if(!vis[v])
     dfs(v);
    }

}

附上全部代码:

#include<iostream>
using namespace std;
#define VertexSize 10
int visit[VertexSize];

typedef struct
{
	int weight[VertexSize][VertexSize];
}Graph;

void Initiate_Graph(Graph *g,int n)
{
	int i,j;
	for(i=0;i<n;i++)
		visit[i]=0;
		for(j=0;j<n;j++)
		{
			if(i==j) g->weight[i][j]=0;
			else g->weight[i][j]=0x7fff;
		}
}

void InsertEdge(Graph *g,int v,int w,int weight,int n)
{
	if(v<0 || v>=n||w<0||w>=n)
	{
		cout<<"overflow!"<<endl;
	}
	g->weight[v][w]=weight;
}

void dfs(Graph *g,int u,int n)
{
	cout<<u<<" ";
	visit[u]=1;
	int i;
	for(i=0;i<n;i++)
	{
		if(g->weight[u][i]>0 && g->weight[u][i]<0x7fff && !visit[i])
		{
			visit[i]=1;
			dfs(g,i,n);
		}
	}
}

void main()
{
	Graph g;
	int n,edge;
	cout<<"请输入图的顶点个数:"<<endl;
	cin>>n;
	cout<<"请输入图的边个数"<<endl;
	cin>>edge;
	Initiate_Graph(&g,n);
	int i,p1,p2,weight;
	cout<<"请输入顶点-顶点-权值:"<<endl;
	for(i=0;i<edge;i++)
	{
		cin>>p1>>p2>>weight;
		InsertEdge(&g,p1,p2,weight,n);
	}
	dfs(&g,0,n);
	system("pause");
}
时间: 2024-08-24 21:24:21

如何实现深度优先遍历(DFS)的相关文章

广度优先遍历-BFS、深度优先遍历-DFS

广度优先遍历-BFS 广度优先遍历类似与二叉树的层序遍历算法,它的基本思想是:首先访问起始顶点v,接着由v出发,依次访问v的各个未访问的顶点w1 w2 w3....wn,然后再依次访问w1 w2 w3....wn的所有未被访问的邻接顶点:再从这些访问过的顶点出发,再访问它们所有未被访问过的邻接顶点......依次类推,直到图中的所有点都被访问为止.类似的思想还将应用于Dijkstra单源最短路径算法和Prim最小生成树算法. python实现二叉树的建立以及遍历(递归前序.中序.后序遍历,队栈前

图的深度优先遍历DFS

图的深度优先遍历是树的前序遍历的应用,其实就是一个递归的过程,我们人为的规定一种条件,或者说一种继续遍历下去的判断条件,只要满足我们定义的这种条件,我们就遍历下去,当然,走过的节点必须记录下来,当条件不满足后,我们就return,回到上一层,换个方向继续遍历. 模板: 1 //邻接矩阵存储方式 2 bool visited[MAX]; 3 void dfs(MGraph G,int i) 4 { 5 int j; 6 visited[i]=true; 7 cout<<G.vex[i]<&

算法学习 - 图的深度优先遍历(DFS) (C++)

深度优先遍历 在图的遍历中,其中深度优先遍历和广度优先遍历是最常见,也最简单的两种遍历方法. 深度优先遍历的思想就是一直向下找,找到尽头之后再去其他分支查找. 在上一篇博客中我已经写了广度优先遍历(BFS). 想看的传送门:图的广度优先遍历 代码实现 这里实现和BFS的差别在于,在BFS中,我们使用的容器是队列(queue),是先进先出的, 而在DFS中我们需要使用的是栈(stack)一个先进后出的容器. 其他基本原理相同. // // main.cpp // DFS // // Created

图的深度优先遍历(DFS)—递归算法

实验环境:win10, DEV C++5.11 实验要求: 实现图的深度优先遍历 实验代码: #include <iostream> #define maxSize 255 #include "stdlib.h" /* run this program using the console pauser or add your own getch, system("pause") or input loop */ /*the definition of s

图的深度优先遍历(DFS) c++ 非递归实现

深搜算法对于程序员来讲是必会的基础,不仅要会,更要熟练.ACM竞赛中,深搜也牢牢占据着很重要的一部分.本文用显式栈(非递归)实现了图的深度优先遍历,希望大家可以相互学习. 栈实现的基本思路是将一个节点所有未被访问的“邻居”(即“一层邻居节点”)踹入栈中“待用”,然后围绕顶部节点猛攻,每个节点被访问后被踹出.读者可以自己画图分析一下,难度并不大. 代码写的比较随意,仅供参考.~ #include <iostream> #include <stack> using namespace

图的深度优先遍历(DFS)和广度优先遍历(BFS)算法分析

1. 深度优先遍历 深度优先遍历(Depth First Search)的主要思想是: 1.首先以一个未被访问过的顶点作为起始顶点,沿当前顶点的边走到未访问过的顶点: 2.当没有未访问过的顶点时,则回到上一个顶点,继续试探别的顶点,直至所有的顶点都被访问过. 在此我想用一句话来形容 “不到南墙不回头”. 1.1 无向图的深度优先遍历图解 以下"无向图"为例: 对上无向图进行深度优先遍历,从A开始: 第1步:访问A. 第2步:访问B(A的邻接点). 在第1步访问A之后,接下来应该访问的是

数据结构(15):图 深度优先遍历(DFS)

/*-----------------------------------------------*/ /* 邻接矩阵的DFS */ // 基于 数据结构(14) 中的邻接矩阵的结构 #include <iostream> using namespace std; typedef char VertexType; typedef int EdgeType; const int MAXVEX = 100; const int INFINITY = 65535; typedef struct {

(原创)不过如此的 DFS 深度优先遍历

DFS 深度优先遍历 DFS算法用于遍历图结构,旨在遍历每一个结点,顾名思义,这种方法把遍历的重点放在深度上,什么意思呢?就是在访问过的结点做标记的前提下,一条路走到天黑,我们都知道当每一个结点都有很多分支,那么我们的小人就沿着每一个结点走,定一个标准,比如优先走右手边的路,然后在到达下一个结点前先敲敲门,当一个结点的所有门都被敲了个遍都标记过,那么就走回头路,再重复敲门,直到返回起点,这样的方式我们叫做 DFS 深度优先遍历,本文以图结构讲解,例子取自<大话数据结构>. 如我刚才所讲,从A点

python实现图广度优先遍历、深度优先遍历

一.广度优先遍历-bfs 顾名思义,bfs总是先访问完同一层的结点,然后才继续访问下一层结点,它最有用的性质是可以遍历一次就生成中心结点到所遍历结点的最短路径,这一点在求无权图的最短路径时非常有用.广度优先遍历的核心思想非常简单,用python实现起来也就十来行代码.下面就是超精简的实现,用来理解核心思想足够了: 1 import queue 2 3 def bfs(adj, start): 4 visited = set() 5 q = queue.Queue() 6 q.put(start)

深度优先遍历(DFS)和广度优先遍历(BFS)

1 图的两种存储方式 1.1 邻接矩阵(Adjacency Matrix) 1.1.1 原理 用一维数组存储图中顶点信息:用二维数组(矩阵)存储图中的边和弧的信息.对于无向图来说,如果顶点i与顶点j之间有边,就将A[i][j]和A[j][i]标记为1:对于有向图来说,如果顶点i和顶点j之间,有一条箭头从顶点i指向顶点j的边,就将A[i][j]标记为1,有箭头从顶点j指向顶点i的边,就将A[j][i]标记为1.对于有权图,数组中存储相应权重. 邻接矩阵可表示为: vertex[4] = {v0,