图的遍历：DFS BFS

深度优先遍历

1．深度优先遍历的递归定义

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

　　图的深度优先遍历类似于树的前序遍历。采用的搜索方法的特点是尽可能先对纵深方向进行搜索。这种搜索方法称为深度优先搜索(Depth-First Search)。相应地，用此方法遍历图就很自然地称之为图的深度优先遍历

2.基本实现思想：

（1）访问顶点v；

（2）从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；

（3）重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

3.伪代码

递归实现

（1）访问顶点v；visited[v]=1；//算法执行前visited[n]=0

（2）w=顶点v的第一个邻接点；

（3）while（w存在） 

if（w未被访问）

从顶点w出发递归执行该算法； 
w=顶点v的下一个邻接点；

    public void DFS1(int v , int [] visited){
        Node p = new Node() ;
        System.out.println("访问顶点"+v) ;
        visited[v] = 1 ;
        p = List[v].head.next ;
        while(p!=null){
            if( visited[p.index] == 0 && p.index != 0)
                DFS1( p.index , visited) ;
            p = p.next ;
        }
    }

 

算法的伪代码描述为：

（1）初始化栈

（2）输出起始节点，并标记为已访问，将该节点压入栈

（3）While（栈不为空）

a.取得栈顶节点Top，注意不要从站内删除;

b.遍历栈顶节点Top的相邻节点adjacentNode，如果该节点adjacentNode未被标记为已

访问，则

输出节点adjacentNode；

标记adjacentNode为已访问；

把adjacentNode压入栈；

c.如果没有满足条件的相邻节点adjacentNode,将栈顶节点Top出栈;

使用情形：

1.深度优先策略常用于连通图的遍历

2.深度优先策略也广泛应用于寻找一条满足某种条件的路径。

算法的时间复杂度为O(n)，其中n为节点个数。 

public void DFS(int v ){
		int[]stack = new int[1000] ;
		int[]visited = new int[1000] ;
		int top = 0 ;
		stack[top++] = v ;
		System.out.println("访问"+v) ;
		visited[v] = 1 ;
		while(top >=1){
			Node q = new Node() ;
			q = List[stack[top-1]].head.next ;
			boolean fact = true ;
			while(q!= null && visited[q.index] == 0 && q.index != 0){//我的数组下表从1开始，没有0，所以不能等于0
				fact = false ;
				System.out.println("访问"+q.index) ;
				visited[q.index] = 1 ;
				stack[top++] = q.index ;
				q = q.next ;
			}
			if(fact){
				top -- ;
			}
		}
	}

广度优先搜索

思想是：假设初始状态时所有顶点都没有被访问过，则从图中某一顶点V出发，访问V。然后访问V的全部邻接点V1  v2 v3 .......................;然后然后依次访问这些点的全部邻接点（已访问的除外）；在从这些被访问的顶点出发，主次访问他们的邻接点（已访问的除外）。他、以此类推，知道所有的点都访问完为止。换句话说，广度优先搜索遍历图就是以v为起点，由近至远，依次访问和v有路径相同的路径长度为1.2.3的顶点。

2.基本实现思想

（1）顶点v入队列。

（2）当队列非空时则继续执行，否则算法结束。

（3）出队列取得队头顶点v；访问顶点v并标记顶点v已被访问。

（4）查找顶点v的第一个邻接顶点col。

（5）若v的邻接顶点col未被访问过的，则col入队列。

（6）继续查找顶点v的另一个新的邻接顶点col，转到步骤（5）。

直到顶点v的所有未被访问过的邻接点处理完。转到步骤（2）。

广度优先遍历图是以顶点v为起始点，由近至远，依次访问和v有路径相通而且路径长度为1，2，……的顶点。为了使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问，需设置队列存储访问的顶点。

3.伪代码

（1）初始化队列Q；visited[n]=0；

（2）访问顶点v；visited[v]=1；顶点v入队列Q

（3） while（队列Q非空）

v=队列Q的对头元素出队；

w=顶点v的第一个邻接点；

while（w存在）

如果w未访问，则访问顶点w；

visited[w]=1；

顶点w入队列Q；

w=顶点v的下一个邻接点。

 

public void BFS(int k , int []visited){
		int[]queue = new int[20] ;
		int r = 0 ;int f = 0 ;
		System.out.println("访问"+k) ;
		visited[k] = 1 ;
		r = (r+1)%20 ;
		queue[r] = k ;
		while( r != f){
			Node p = new Node();
			f = (f+1)%20;
			p = List[queue[f]].head.next;
			while(p!=null){
				if(visited[p.index] == 0 && p.index != 0){//我的数组下表从1开始，没有0，所以不能等于0
					System.out.println("访问"+p.index);
					visited[p.index] = 1 ;
					r = (r+1)%20 ;
					queue[r] = p.index ;
				}
				p = p.next ;
			}
			
		}
	}