数据结构——图的遍历

                               图的遍历

     树常见的遍历方式有先序、中序、后序以及层次遍历，同样，图也有常见的两种遍历方式，分别是深度优先搜索(DFS)和广度优先搜索(BFS)。见名知意，深搜的策略就是从一个节点开始，访问到一个节点就标记一下，向第一个邻接节点方向搜，如果第一个邻接节点已经被标记访问过了，就向每二个邻接节点方向搜等等，再后再向第一个邻接节点的第一个邻接节点搜，这样递归搜索，直到当前访问的节点的所有邻接节点都被标记为访问过，这时就回溯。按照这种策略，图中的每个节点都可以被访问到，而且只会被访问一次。

     下面是DFS搜索基于邻接矩阵图的代码实现

	//深搜
	template<typename T>
	void AdjMatrixDirGraph<T>::DFSTraverse(void(*visit)(const T &t))
	{
		DFSTraverseHelper(0, visit);
		for (int i = 0;i < vexNum;i++)
		{
			tags[i] = 0;
		}
	}

template<typename T>
	void AdjMatrixDirGraph<T>::DFSTraverseHelper(const int v,void(*visit)(const T &t))
	{
		SetTag(v, 1);
		T elem;
		GetElem(v, elem);
		visit(elem);
		int tag = 1;
		for (int w = FirstAdjVex(v);w >= 0;w=NextAdjVex(v,w))
		{
			if (GetTag(w, tag))
			{
				if (tag == 0)
				{
					DFSTraverseHelper(w, visit);
				}
			}
		}

	}

这是在 前面的博客代码基础上修改的，实现了遍历算法。这里有一些问题，需要把图的定义接口中的DFS和BFS的const去掉，因为在这些方法中修改了tags的内容，不能再把函数const了。

测试代码如下

#include "stdafx.h"
#include <iostream>
#include "adjmatrixdirgraph.h"
using namespace std;
using namespace dataStructure;
void visit(const char &c)
{
	cout << c << ",";
}

int main()
{
	int **matrix = new int*[5];
	for (int i = 0;i < 5;i++)
	{
		matrix[i] = new int[5];
		for (int j = 0;j < 5;j++)
		{
			matrix[i][j] = 0;
		}
	}

	matrix[0][2] = 1;
	matrix[0][3] = 1;
	matrix[1][2] = 1;
	matrix[1][4] = 1;
	matrix[2][0] = 1;
	matrix[2][1] = 1;
	matrix[2][4] = 1;
	matrix[3][0] = 1;
	matrix[4][1] = 1;
	matrix[4][2] = 1;

	Graph<char> *graph = new AdjMatrixDirGraph<char>(matrix, 5);
	graph->SetElem(0, 'A');
	graph->SetElem(1, 'B');
	graph->SetElem(2, 'C');
	graph->SetElem(3, 'D');
	graph->SetElem(4, 'E');
	graph->DFSTraverse(visit);
	system("pause");
	return 0;
}

执行结果

然后是广度搜索，广度优先搜索的策略也很简单，就是向当前节点的所有邻接节点访问，把这些邻接节点访问过再把第一个邻接节点当作当前节点进行搜索，搜索完后再把第一次访问的节点的第二个邻接节点当作当前节点进行搜索，这些一直把图中所有的节点全部搜索完。根据这个算法，可以发现需要一个队列。因为广度搜索的策略就是从近往远处搜索，要先把近处的先搜索，如何来先搜索最近的节点呢？那就是根据当前的邻接节点，把这些邻接节点放入一个先进先出的队列中，这个队列中离当前节点更近的节点一定在前面，因为第一次搜索就搜的是最近的节点，第一次就把最近的几个节点放入了队列，而后面再放入的是当前节点的邻接节点的邻接节点，这些第二层的邻接节点由于先进先出的队列特性，肯定被放在了第一层邻接节点的后面。在BFS算法中使用队列非常巧妙。

下面是基于邻接矩阵图的BFS实现代码

template<typename T>
	void AdjMatrixDirGraph<T>::BFSTraverseHelper(const int v,void(*visit)(const T &t))
	{
		SetTag(v, 1);
		T elem;
		GetElem(v, elem);
		visit(elem);
		int *queue = new int[vexNum+1];
		int front = 0, rear = 0;
		queue[rear++] = v;
		int p;
		int tag = 1;
		while(front != rear)
		{
			p = queue[front++];
			for (int w = FirstAdjVex(p);w >= 0;w=NextAdjVex(p,w))
			{
				if(GetTag(w,tag))
				{
					if (tag == 0) 
					{
						SetTag(w, 1);
						GetElem(w, elem);
						visit(elem);
						queue[rear++] = w;
					}
				}
			}
		}
	}

//广搜
	template<typename T>
	void AdjMatrixDirGraph<T>::BFSTraverse(void(*visit)(const T &t))
	{

		BFSTraverseHelper(0, visit);
		for (int i = 0;i < vexNum;i++)
		{
			tags[i] = 0;
		}
	}

下面是测试代码

#include "stdafx.h"
#include <iostream>
#include "adjmatrixdirgraph.h"
using namespace std;
using namespace dataStructure;
void visit(const char &c)
{
	cout << c << ",";
}

int main()
{
	int **matrix = new int*[5];
	for (int i = 0;i < 5;i++)
	{
		matrix[i] = new int[5];
		for (int j = 0;j < 5;j++)
		{
			matrix[i][j] = 0;
		}
	}

	matrix[0][2] = 1;
	matrix[0][3] = 1;
	matrix[1][2] = 1;
	matrix[1][4] = 1;
	matrix[2][0] = 1;
	matrix[2][1] = 1;
	matrix[2][4] = 1;
	matrix[3][0] = 1;
	matrix[4][1] = 1;
	matrix[4][2] = 1;

	Graph<char> *graph = new AdjMatrixDirGraph<char>(matrix, 5);
	graph->SetElem(0, 'A');
	graph->SetElem(1, 'B');
	graph->SetElem(2, 'C');
	graph->SetElem(3, 'D');
	graph->SetElem(4, 'E');
	//graph->DFSTraverse(visit);
	graph->BFSTraverse(visit);
	system("pause");
	return 0;
}

执行结果如下

这个代码中使用的队列不是专门去写个数据结构或用个专门的队列，其实队列和栈可以用数组和一些int型指示下标位置的"指针"来简单的实现，这样的好处是节约内存且代码全在算法内部，更具整洁性。其实这里可以根据图的结构来预测BFS时需要的队列的最大长度，也就队列中同时最多有多少个节点入队列，然后使用循环队列来实现，比如说如果这个图是个稠密图的话，而且图的节点非常非常多时，用循环队列将会非常节约内存。