深度优先搜索(DFS)与广度优先搜索(BFS)

图遍历的过程其实很容易理解(很多方法即使不看书也能比划出来)，难点是思路清晰的用计算机理解的方式表达出来。
矩阵是一种表示图的信息很好的方法(顶点比较少时适用)，每个顶点与其它顶点的关联都可以表示出来。
矩阵每行代表每个顶点可以访问的其它顶点（列可以想象成某顶点可以被哪些其它顶点访问）。

直接看代码与注释：

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
using namespace std;

#define DONE 1  //visitedV
#define UNDONE 0  
#define VERTEXNUM 6 //顶点个数

bool visitedV[VERTEXNUM];

//邻接矩阵存储结构
typedef struct
{
	char vertexs[VERTEXNUM]; //顶点
	int edges[VERTEXNUM][VERTEXNUM]; //邻接矩阵
	int verNum, edgeNum; //图中顶点和边数
}Graph;

//建立邻接矩阵
void MakeGraph(Graph *graph)
{
	int i, j, k;
	/*
	//自定义输入顶点数和边数
	printf("请输入顶点数和边数:\n");
    scanf("%d%d", &graph->verNum, &graph->edgeNum);
    */
	graph->verNum = 6;
	graph->edgeNum = 6;
	//char my_vertexs[6] = {'a','b','c','d','e','f'};	
	char my_vertexs[6] = {'1','2','3','4','5','6'};

	//printf("请输入顶点信息,每个顶点以回车作为结束:\n");
	for(i = 0; i < graph->verNum; i++)
	{
	    /*
		//自定义输入结点集vetex
		getchar();
		scanf("%c", &graph->vertexs[i]);
		*/
		graph->vertexs[i] = my_vertexs[i];
	}
	for(i = 0; i < graph->verNum; i++) //初始化邻接矩阵
	{
		for(j = 0; j < graph->verNum; j++)
		{
			graph->edges[i][j] = 0;
		}
	}
	/*
	//自定义输入边集edge
	printf("请输入每条边对应的两个顶点的序号(输入格式为:i,j):\n");	
	for(k = 0; k < graph->edgeNum; k++)
	{
		//scanf("%d,%d", &i, &j);
		//graph->edges[i - 1][j - 1] = 1; //(vi->vj)将edges[i][j]设置为1表示i,j间存在边		
	}
	*/
	
	int my_edges[6][6] = {
       //1,2,3,4,5,6 
/*1*/	{0,1,0,0,1,0},
/*2*/	{1,0,0,1,1,0},
/*3*/	{0,0,0,0,1,0},
/*4*/	{0,1,0,0,0,0},
/*5*/	{1,1,1,0,0,1},
/*6*/	{0,0,0,0,0,0}
	};
	for(int i=0; i<6; i++)
	  for(int j = 0; j<6; j++)
	    graph->edges[i][j] = my_edges[i][j];
	  
}

/*
深度优先搜索
int my_edges[6][6] = {
       //1,2,3,4,5,6 
  //1	{0,1,0,0,1,0},
  //2	{1,0,0,1,1,0},
  //3	{0,0,0,0,1,0},
  //4	{0,1,0,0,0,0},
  //5	{1,1,1,0,0,1},
  //6	{0,0,0,0,0,0}}
原理与步骤：  
从“顶点1”开始访问，数组my_edges[6][6]中的第1行就是“顶点1”相关联的顶点信息，首先读到“顶点2”.
(将顶点1、2标记为已读)

从“顶点2”开始访问，数组my_edges[6][6]中的第2行就是“顶点2”相关联的顶点信息，(忽略已读顶点)首先读到“顶点4”.
(将“顶点4”标记为已读)；

从“顶点4”开始访问，数组my_edges[6][6]中的第4行就是“顶点4”相关联的顶点信息，“顶点4”关联的数据之前已读；

(递归)返回到“顶点2”中，继续读第2行与“顶点2”相关联的节点信息，读到“顶点5”.
(将“顶点5”标记为已读)；

从“顶点5”开始访问，数组my_edges[6][6]中的第5行就是结点5相关联的顶点信息，首先读到“顶点3”.
(将“顶点3”标记为已读)；

从“顶点3”开始访问，数组my_edges[6][6]中的第3行就是“顶点3”相关联的顶点信息，“顶点3”关联的数据之前已读；

(递归)返回到“顶点5”中，继续读第5行与“顶点5”相关联的顶点信息，读到“顶点6”.
(将“顶点6”标记为已读)，此时所有数据已经遍历。

(递归)返回“顶点5”
(递归)返回“顶点2”
(递归)返回“顶点1”

整个过程如下：(==>进入递归，-->跳出递归)
1==>2==>4-->2==>5==>3-->5==>6-->5-->2-->1
画出来看到是二叉树的前序遍历呢！ 

说简单点：按照一定规则，寻找与当前结点相关联的下一个（第1个）顶点，再找下一个结点的下一个（第1个）顶点，待所有顶点遍历完，逐步跳回。
*/

void DFSTraverse(Graph *graph, int i)
{
	printf("深度优先遍历:顶点%c\n", graph->vertexs[i]);
	visitedV[i] = DONE;
	for(int j = 0; j < graph->verNum; j++) //遍历“顶点i”对应的所有"顶点"
	{
		if(graph->edges[i][j] == 1 && !visitedV[j])
		{
			DFSTraverse(graph, j);//j为本次递归结果的输出，用作下层递归的输入
		}
	}
}

void DFS(Graph *graph)
{
	int i;
	for(i = 0; i < graph->verNum; i++)
		visitedV[i] = UNDONE;
	for(i = 0; i < graph->verNum; i++)
		if(!visitedV[i])
			DFSTraverse(graph, i);
}


/*
广度优先搜索
	int my_edges[6][6] = {
       //1,2,3,4,5,6 
  //1	{0,1,0,0,1,0},
  //2	{1,0,0,1,1,0},
  //3	{0,0,0,0,1,0},
  //4	{0,1,0,0,0,0},
  //5	{1,1,1,0,0,1},
  //6	{0,0,0,0,0,0}}
原理：  
从"顶点1"开始访问，数组my_edges[6][6]中的第一行就是"顶点1"相关联的顶点信息，将"顶点2和5"依次加入队列queue.（queue:2,5 ）
标记"顶点1,2,5"已经被遍历visitedV[6] = {DONE,DONE,0,0,DONE,0};

从队列中读出"顶点2"并出列，访问第2行中与"顶点2"关联的顶点，已经遍历过了的跳过，将"顶点4"加入队列queue.(queue:5,4)
标记顶点4已结被遍历visitedV[6] = {DONE,DONE,0,DONE,DONE,0};  

从队列中读出"顶点5"并出列，访问第5行中与"顶点5"关联的顶点，已经遍历过了的跳过，将"顶点3和6"加入队列queue. (queue:4,3,6)
标记顶点3和6已经被遍历visitedV[6] = {DONE,DONE,DONE,DONE,DONE,DONE};  

此时所有数据已经被全部遍历。
(queue:4,3,6)出列
*/
void BFS(Graph *graph)
{
	int i, j, k;
	queue<int> q;
	for(i = 0; i < graph->verNum; i++) 
		visitedV[i] = UNDONE; //遍历之前，标记为UNDONE

	for(i = 0; i < graph->verNum; i++)
	{
		if(!visitedV[i])
		{
			visitedV[i] = DONE;
			printf("广度优先遍历:顶点%c\n", graph->vertexs[i]);
			q.push(i); //将遍历后的顶点，存入队列中
			while(!q.empty())
			{
				j = q.front(); //读取队列中第一个(顶点)数据，用于后边遍历该顶点相关联的顶点
				q.pop();  //删除队列中第一个数据
				for(k = 0; k < graph->verNum; k++)
				{
					if(graph->edges[j][k] == 1 && !visitedV[k])
					{
						printf("广度优先遍历:顶点%c\n", graph->vertexs[k]);
						visitedV[k] = DONE;
						q.push(k);//将与j这一行找到的相关联的数据存入队列中
					}
				}
			}
		}
	}
}

int main()
{
	Graph *graph = (Graph *)malloc(sizeof(Graph));
	MakeGraph(graph); // 建立图
	DFS(graph); //深度优先搜索
        cout<<"*********************************************************"<<endl;
	BFS(graph);//广度优先搜索
	free(graph);
	return 0;
}