图的遍历(BFS与DFS)

输入：建立图的存储结构：顶点和边（弧），例：无向图G的顶点V=｛A，B，C，D，E，F，G，H｝，边E=｛（A,B），（A,C），（B,D），（B,E），（C,F），（C,G），（D,H），（E,H），（F,G）｝（G具有8个顶点和9条边）

输出：深度优先遍历的顶点序列（按照存储结构）：A,B,D,H,E,C,F,G（或者其它的不同顺序的序列）

package aa;

import java.util.LinkedList;
import java.util.Queue;

public class Graph {
	// 顶点数
	private int number = 8;
	// 记录顶点是否被访问
	private boolean[] flag;
	// 记录顶点
	private String[] vertexs = { "A", "B", "C", "D", "E", "F", "G", "H" };
	// 记录边
	private int[][] edges = { { 0, 1, 1, 0, 0, 0, 0, 0 }, { 1, 0, 0, 1, 1, 0, 0, 0 }, { 1, 0, 0, 0, 0, 1, 1, 0 },
			{ 0, 1, 0, 0, 0, 0, 0, 1 }, { 0, 1, 0, 0, 0, 0, 0, 1 }, { 0, 0, 1, 0, 0, 0, 1, 0 },
			{ 0, 0, 1, 0, 0, 1, 0, 0 }, { 0, 0, 0, 1, 1, 0, 0, 0 }, };

	// 图的深度优先遍历
	public void DFSTraverse() {
		flag = new boolean[number];
		for (int i = 0; i < number; i++) {// 遍历每个顶点
			if (flag[i] == false) {
				DFS(i);
			}
		}
	}

	// 图的深度优先递归算法
	private void DFS(int i) {
		System.out.print(vertexs[i] + " ");
		flag[i] = true;
		for (int j = 0; j < number; j++) {
			if (flag[j] == false && edges[i][j] == 1) {
				DFS(j);
			}
		}
	}

	// 图的广度优先遍历
	public void BFSTraverse() {
		boolean[] flag = new boolean[number];
		Queue<Integer> queue = new LinkedList<Integer>();
		for (int i = 0; i < number; i++) {
			if (flag[i] == false) {
				System.out.print(vertexs[i] + " ");
				flag[i] = true;
				queue.add(i);
				while (!queue.isEmpty()) {
					int k = queue.poll();
					for (int j = 0; j < number; j++) {
						if (flag[j] == false && edges[k][j] == 1) {
							System.out.print(vertexs[j] + " ");
							flag[j] = true;
							queue.add(j);
						}
					}
				}
			}
		}
	}

	public static void main(String[] args) {
		Graph g = new Graph();
		System.out.println("图的深度优先遍历:");
		g.DFSTraverse();
		System.out.println();
		System.out.println("图的深度优先遍历:");
		g.BFSTraverse();
	}
}