[数据结构]Graph之深度优先遍历(DFT)及广度优先遍历(BFT)

Posted yccy1230

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[数据结构]Graph之深度优先遍历(DFT)及广度优先遍历(BFT)相关的知识,希望对你有一定的参考价值。

写在前面:以下图的实现采用邻接表的形式,看之前注意一下


一、广度优先遍历

遍历规则:

假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点),则深度优先遍历可定义如下:首先访问出发点v,并将其标记为已访问过;然后依次从v出发搜索v的每个邻接点w。若w未曾访问过,则以w为新的出发点继续进行深度优先遍历,直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有未访问的顶点,则另选一个尚未访问的顶点作为新的源点重复上述过程,直至图中所有顶点均已被访问为止。---------百度百科


简单来说,就是对一个图进行遍历,遍历过程中对一条路径尽可能深的遍历,直至“无路可走”,再返回上一个节点判断其是否存在可走的路径


算法描述:递归实现

准备:建立一个visited[max_size]数组,用于记录顶点是否被访问过

base case:若传入顶点的每个“邻居”都已经被访问过,则结束当前递归

general case:对传入顶点进行访问,并对当前顶点的“邻居”进行判断,若存在未被访问的“邻居”,则转换为对该顶点的访问


实现代码:

template<int max_size>
void Graph<max_size>::depth_First(void(*visit)(Vertex &)) const

	bool visited[max_size];		//记录点是否已被访问
	for (int i = 0; i < max_size; i++)visited[i] = false;
	for (Vertex v = 0; v < count; v++) 
		if (!visited[v])tranverse(v, visited, visit); //对第一个节点开始递归
	

template<int max_size>
void Graph<max_size>::tranverse(Vertex & x, bool visited[], void(*visit)(Vertex &))const

	visited[x] = true;			//对当前节点进行访问
	(*visit)(x);					//并将改点置为已访问
	for (int i = 0; i < neighbours[x].size(); i++) 	
		Vertex w;
		neighbours[x].retrieve(i, w);
		if (!visited[w])tranverse(w, visited, visit);	//转换为对没有被访问过的节点的遍历
	


-------------------------------------------------------------------------------

二、广度优先遍历

遍历规则:

1、从图中某个顶点V0出发,并访问此顶点;

2、从V0出发,访问V0的各个未曾访问的邻接点W1,W2,…,Wk;然后,依次从W1,W2,…,Wk出发访问各自未被访问的邻接点;

3、重复步骤2,直到全部顶点都被访问为止。

-------百度百科


百科的叙述已经挺清楚了,用再直白的话说,就是对一个图进行访问,首先对起点访问,然后对起点 的每一个“邻居进行访问”,都访问完了再对每个“邻居”的“邻居”进行访问。

额。。。好像讲的有点绕了,反正就好像一层一层的遍历一样,尽可能的“广”。


算法描述:

准备:建立一个visited[max_size]数组,用于记录顶点是否被访问过

    建立辅助队列

将第一个顶点做入队操作

若队列中的第一个元素未被访问,则访问,并将其所有“邻居”进行入队操作

将队首元素pop出来

对队列的现队首重复上述操作,直至队列为空


实现代码:


template<int max_size>
void Graph<max_size>::breadth_first(void(*visit)(Vertex &)) const

	queue<Vertex> q;
	bool visited[max_size];
	for (int i = 0; i < max_size; i++)visited[i] = false;
	Vertex v, w, x;
	for (v = 0; v < count; v++) 		//防止出现联通分支的情况
		if (!visited[v]) 			//向队列中添加第一个顶点
			q.push(v);
			while (!q.empty()) 
				w = q.front();
				if (!visited[w]) 	//若没有被访问过,进入循环,对其所有“邻居”进行入队操作
					visited[w] = true;	//因为我们有标记是否被访问过,所以不会重复遍历
					(*visit)(w);
					for (int i = 0; i < neighbours[w].size(); i++) 
						neighbours[w].retrieve(i, x);
						q.push(x);
					
				
				q.pop();	//所有“邻居”都被入队,且当前顶点已被访问,出队
			
		
	



下面附上我的整个project,并附上我的测试用例

(我的输入是按照邻接表的行,一行一行进行输入的)



//Graph.h
#include"Linked_List.cpp"
typedef int Vertex;
template<int max_size>
class Graph

public:
	Graph();
	void inputRow(int row, int count);
	void depth_First(void(*visit)(Vertex &))const;
	void breadth_first(void(*visit)(Vertex &))const;

private:
	void tranverse(Vertex &x, bool visited[], void(*visit)(Vertex &))const;
	List<Vertex> neighbours[max_size];
	int count;

;

//Graph.cpp
#include"Graph.h"
#include<queue>

template<int max_size>
Graph<max_size>::Graph()

	count = 0;


template<int max_size>
void Graph<max_size>::inputRow(int row, int count)

	for (int i = 0; i < count; i++) 
		Vertex tmp;
		cin >> tmp;
		neighbours[row].insert(i,tmp);
	
	this->count++;


template<int max_size>
void Graph<max_size>::depth_First(void(*visit)(Vertex &)) const

	bool visited[max_size];		//记录点是否已被访问
	for (int i = 0; i < max_size; i++)visited[i] = false;
	for (Vertex v = 0; v < count; v++) 
		if (!visited[v])tranverse(v, visited, visit); //对第一个节点开始递归
	


template<int max_size>
void Graph<max_size>::breadth_first(void(*visit)(Vertex &)) const

	queue<Vertex> q;
	bool visited[max_size];
	for (int i = 0; i < max_size; i++)visited[i] = false;
	Vertex v, w, x;
	for (v = 0; v < count; v++) 		//防止出现联通分支的情况
		if (!visited[v]) 			//向队列中添加第一个顶点
			q.push(v);
			while (!q.empty()) 
				w = q.front();
				if (!visited[w]) 	//若没有被访问过,进入循环,对其所有“邻居”进行入队操作
					visited[w] = true;	//因为我们有标记是否被访问过,所以不会重复遍历
					(*visit)(w);
					for (int i = 0; i < neighbours[w].size(); i++) 
						neighbours[w].retrieve(i, x);
						q.push(x);
					
				
				q.pop();	//所有“邻居”都被入队,且当前顶点已被访问,出队
			
		
	


template<int max_size>
void Graph<max_size>::tranverse(Vertex & x, bool visited[], void(*visit)(Vertex &))const

	visited[x] = true;			//对当前节点进行访问
	(*visit)(x);					//并将改点置为已访问
	for (int i = 0; i < neighbours[x].size(); i++) 	
		Vertex w;
		neighbours[x].retrieve(i, w);
		if (!visited[w])tranverse(w, visited, visit);	//转换为对没有被访问过的节点的遍历
	



//main.cpp
#include<iostream>
#include"Graph.cpp"
using namespace std;

void visit(Vertex &x) 
	cout << x << ' ';


int main() 
	Graph<10> graph;
	graph.inputRow(0, 3);
	graph.inputRow(1, 3);
	graph.inputRow(2, 2);
	graph.inputRow(3, 1);
	graph.inputRow(4, 3);
	graph.inputRow(5, 3);
	graph.inputRow(6, 2);
	graph.inputRow(7, 1);
	graph.inputRow(8, 2);
	
	graph.depth_First(visit);
	cout << endl;
	graph.breadth_first(visit);
	cout << endl;
	return 0;



以上。

2016/6/12

以上是关于[数据结构]Graph之深度优先遍历(DFT)及广度优先遍历(BFT)的主要内容,如果未能解决你的问题,请参考以下文章

Graph-DFS-图的深度优先遍历

深度优先遍历(Depth-First Traversa Undirected Graph)

Graph-DFS-Map-图的深度优先遍历-城市地图问题

数据结构(三十一)图的遍历之深度优先遍历

Graph 感悟

数据结构Java版之深度优先-图