06 列出连通集 （java实现）

列出连通集 (25分)

给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:

输入第1行给出2个整数N(0

输出格式:

按照"{ v1,v2,…vk​​ }"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:

8 6
0 7
0 1
2 0
4 1
2 4
3 5

输出样例:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }

思路

		分别使用深度优先搜索和广度优先搜索列出给定图的连通集
		1、图的初始化，使用什么存储结构
				本题采用邻接矩阵
		2、图的遍历
				深度优先搜索
				广度优先搜索

import java.util.*;

public class ListConnectedSetDemo 
{
	public static void main(String[] args) 
	{
		/**
			分别使用深度优先搜索和广度优先搜索列出给定图的连通集
			1、图的初始化，使用什么存储结构
					本题采用邻接矩阵
			2、图的遍历
					深度优先搜索
					广度优先搜索
		*/
		Scanner scan = new Scanner(System.in);
		String[] s = scan.nextLine().split(" ");
		int vertex = Integer.parseInt(s[0]);	
		int edge = Integer.parseInt(s[1]);

//1、邻接矩阵存储结构初始化
		int[][] map = new int[vertex][vertex];
		int[] visited = new int[vertex];
		for(int i=0; i<edge; i++){
			String[] s1 = scan.nextLine().split(" ");
			int vertex1 = Integer.parseInt(s1[0]);
			int vertex2 = Integer.parseInt(s1[1]);
			map[vertex1][vertex2] = 1;
			map[vertex2][vertex1] = 1;
		}

//2.1 深度优先搜索。  访问i行的vertex列的值，因为是一个vertex*vertex的方阵
		for(int i=0; i<vertex; i++){
			if(visited[i]!=1){		//访问第i个顶点
				visited[i] = 1;
				System.out.print("{");
				dfs(i, vertex, visited, map);		//遍历第i个顶点所在行的 vertex列的值。输入为：顶点位置i，常数vertex，visited数组(因为没有自回路，所以共用一个visited)，邻接矩阵map[][]
				System.out.println("}");
			}
		}

		reset(visited);

//2.2 广度优先搜索
		for(int i=0; i<vertex; i++){
			if(visited[i]!=1){
				visited[i] = 1;
				System.out.print("{");
				Queue<Integer> queue = new LinkedList<Integer>(); 
				queue.add(i);
				System.out.print(i+" ");
				while(!queue.isEmpty()){
					bfs( queue, vertex, visited, map);
				}
				System.out.println("}");
			}
		}

		scan.close();
	}

	//深度优先搜索函数。  root为根节点，即连通图的顶点
	public static void dfs(int root, int vertex, int[] visited,int[][] map){
		System.out.print(root+" ");		//首先输出第一个顶点
		//遍历邻接顶点
		for(int i=0; i<vertex; i++){
			if(visited[i]!=1 && map[root][i]==1){
				visited[i] = 1;
				dfs(i, vertex, visited, map);
			}
		}
	}
	
	//广度搜索函数。
	public static void bfs(Queue<Integer> queue, int vertex, int[] visited,int[][] map){
		int root = queue.poll();		//检索并删除队列的头
		for(int j=0; j<vertex; j++){
			if(visited[j]!=1 && map[root][j]==1){
				visited[j] = 1;
				queue.add(j);
				System.out.print(j+" ");
			}
		}
	}

	//reset函数，在深度搜索完之后，将visited重新置为0，以便进行广度搜索
	public static void reset(int[] visited){
		for(int i=0; i<visited.length; i++){
			visited[i] = 0;
		}
	}
}