-图的遍历-

图的遍历

图的遍历即总图的某一顶点出发，沿着图的边，将图的所有顶点依次访问依次且只访问一次。

树是一种特殊的图（极小连通子图），所以树的遍历也可以看作一种特殊的图的遍历。

图的遍历算法是求解图的连通性，拓扑排序和求关键路径等算法的基础

树的遍历沿边访问不会访问重复的节点（访问过的节点要从栈中读取），而图沿边访问是可能重复访问节点，因此要设置一个辅助数组visited[MaxVertexNum]来标记顶点是否被访问过

对于图的遍历算法，下述过程是公共的，这是由于依赖于路径的单次遍历只能在连通区域循环访问

bool visited[MaxVertexNum];
void Traverse(Graph G){
	//初始化已访问标识
	for( v = 0; v < G.vexnum; ++v)
		visited[v] = FALSE;
	//对某个节点所在的极大联通图用某种遍历方法遍历		
	for( v = 0; v < G.vexnum; ++v)
		if(!visited[v])
			TraverseMethod(G,v);
}

广度优先搜索

BFS(Breadth-First-Search)

BFS算法

bool visited[MaxVertexNum];

void BFSTraverse(Graph G){
	for( i = 0;i < G.vexnum; i++)
		visited[i] = false;			//访问标记数组初始化
	InitQueue(Q);
	for( i = 0; i < G.vernum; i++){
		if(!visited[i])
			BFS(G,i);				//遍历顶点i所在的极大连通分量			
	}
}

//相当于将根节点为v的树层次遍历，且在遍历的过程中添加对访问标记的判断或修改
void BFS(Graph G,int v){
	visit(v);
	visited[v] = true;
	//类似于树的层次遍历，要借助一个辅助队列
	Enqueue(Q,v);
	while(!isEmpty(Q)){
		DeQueue(Q,v);
		for(w = FirstNeighbor(G,v);w >= 0; w = NextNeighbor(G,v,w)){
			if(!visist[w]){
				visit(w);
				visited[w] = true;
				Enqueue(Q,w);
			}
		}
	}
}

图的广度优先遍历是树的层次遍历算法的扩展

BFS算法的性能分析

无论是邻接表还是邻接矩阵的存储方式，BFS算法都需要借助一个辅助队列Q，n个顶点均需入队一次，在最坏的情况，时间复杂度为O(|V|)。
采用邻接表存储方式时，每个顶点均需搜索一次（或如对一次），故时间复杂度为O(|V|)，在搜索任意顶点的邻接表时，每条边至少访问一次，故时间复杂度为O(|E|),算法总的时间复杂度为O(|V| + |E|)。采用邻接矩阵存储方式时，查找每个顶点的邻接点所需要的时间为O(|V|),故算法总的时间复杂度为O(|V|^2)

BFS算法求解单源最短路径问题

由于广度优先遍历是由近及远的，而且每次BFS遍历都是在一个最大连通分量上的遍历，因此可以在BFS算法的循环中计算路径长度

void BFS_MIN_Distance(Graph G,int u){
	//d[i]记录从u到i节点的最短路径
	for(i = 0;i < G.vernum;i++)
		d[i] = -1;//初始化路径长度
		visited[u] = ture; d[u] = 0;
		EnQueue(Q,u);
		while(!isEmpty(Q)){
			DeQueue(Q,u);
			for(w = FirstNeighbor(G,u);w >= 0;w = NextNeighbor(G,u,w)){
				if(!visited[w]){
					visited[w] = ture;
					d[w] = d[u] + 1;//注意u是动态的，每次的u都是上个循环访问的访问标识为否的节点
					EnQueue(Q,w);
				}
			}
		}
}

广度优先生成树

生成方法为层次遍历访问节点时确定书的节点
在广度优先遍历的过程中，我们可以得到一颗遍历树，称为广度优先生成树，一个顶的邻接矩阵存储表示唯一，其广度优先生成树也是唯一的，但是邻接矩阵表示不唯一，其广度优先生成树也是不唯一的。

深度优先搜索

DFS算法

bool visited[[MaxVertexNum];
void DFSTraverse(Graph G){
	for(v = 0; v < G.verum; v ++)
		visited[v] == FALSE;
	for(v = 0; v < G.vernum; v ++)
		DFS(G,v);	
}
//类似于树的先序遍历
DFS(Graph G,int v){
	//访问顶点v
	visit(v);
	//访问后修改已访问标识
	visited[v] = TRUE;
	//递归的DFS访问（先序遍历）；访问前检测已访问标识
	for( w = FirstNeibor(G,v); w != 0; w = NextNeibor(G,v,w)
		if(!visited[w]){
			DFS(G,w);
		}
}

DFS算法的性能分析

由于用到递归算法要借助工作栈，所以空间复杂度为O(|V|)。
算法的时间复杂度依赖于FirstNeibor和NextNeibor两个函数，根据不同的存储结构，这两个函数有不同的时间复杂度。
在邻接矩阵中，FirstNeibor和NextNeibor的时间复杂度均为O(|V|)，即遍历第v行所需要的时间，故总的时间复杂度为O(|V|^2)；在邻接表中，访问所有FirstNeibor的时间代价为|V|,访问所有NextNeibor的时间代价为|E|（所有循环累计），所以总的时间复杂度为O(|V|+|E|)

深度优先的生成树和生成森林

生成方法为先序遍历访问时确定一个节点
连通图可以生成树 非连通图生成森林（每个极大连通图生成一棵树）
基于邻接矩阵存储的图可以唯一确定一颗深度优先生成树
基于邻接表存储的图不可以唯一确定一颗深度优先生成树

图的遍历和连通性

在Traverse函数的第二个循环中，

	num = 0;
	for( i = 0; i < G.vernum; i++){
		if(!visited[i])
			num ++;
			TraverseMethod(G,i);				//遍历顶点i所在的极大连通分量			
	}

即可得到连通分量数