图的深度优先遍历（DFS）基本介绍：

图的深度优先搜索(Depth First Search) ：
1）、深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
2）、我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
3）、显然，深度优先搜索是一个递归的过程

图的广度优先搜索(BFS)基本介绍：

类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

具体案例：

使用深度优先遍历和广度优先遍历显示下图：

java树形广度优先遍历_Java

DFS算法步骤：

  • 访问初始结点v，并标记结点v为已访问。
  • 查找结点v的第一个邻接结点w。
  • 若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。
  • 若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
  • 查找结点v的w邻接结点的下一个邻接结点，转到步骤3。

BFS算法步骤：

  • 访问初始结点v并标记结点v为已访问。
  • 结点v入队列
  • 当队列非空时，继续执行，否则算法结束。
  • 出队列，取得队头结点u。
  • 查找结点u的第一个邻接结点w。
  • 若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
    1 、若结点w尚未被访问，则访问结点w并标记为已访问。
    2 、结点w入队列
    3 、查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

代码实现：

package graph;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Graph {
	// 存放每个结点内的数据
	private ArrayList<String> vertexList;
	// 存放图对应的邻接矩阵
	private int[][] edges;
	// 存放边的数目
	private int numOfEdges;
	// 构建一个数组存放顶点是否被访问
	private boolean[] isVisited;

	public static void main(String[] args) {
		int n = 5;
		Graph graph = new Graph(5);
		String[] vertexValue = { "A", "B", "C", "D", "E" };
		// 建立各顶点所对应的值
		for (String vertex : vertexValue) {
			graph.insertVertex(vertex);
		}
		// 构造边的关系
		graph.insertEdges(0, 1, 1);
		graph.insertEdges(0, 2, 1);
		graph.insertEdges(1, 2, 1);
		graph.insertEdges(1, 3, 1);
		graph.insertEdges(1, 4, 1);
		graph.showGraph();
		
		//深度遍历
		System.out.println("深度优先遍历：");
		graph.dfs();
		System.out.println();
		//广度遍历
		System.out.println("广度优先遍历：");
		graph.bfs();

	}

	/**
	 * 
	 * @param 顶点个数
	 */
	public Graph(int n) {
		edges = new int[n][n];
		vertexList = new ArrayList<String>(n);
		
	}

	/**
	 * 
	 * @Title: insertVertex
	 * @Description: 向顶点中加入该顶点的数据
	 * @param @param vertex 要插入的数据
	 * @return void 返回类型
	 */
	public void insertVertex(String vertex) {
		vertexList.add(vertex);
	}

	/**
	 * 
	 * @Title: insertEdges
	 * @Description: 将邻接矩阵各个结点之间的关系建立起来，1代表相连，0代表不相连
	 * @param @param v1 代表下标为v1的顶点
	 * @param @param v2 代表下标为v2的顶点
	 * @param @param weight 权值，不是0就是1
	 * @return void 返回类型
	 */
	public void insertEdges(int v1, int v2, int weight) {
		edges[v1][v2] = weight;
		edges[v2][v1] = weight;
		numOfEdges++;
	}

	// 返回结点数
	public int getNumOfVertex() {
		return vertexList.size();
	}

	// 返回边数
	public int getNumOfEdges() {
		return numOfEdges;
	}

	// 返回i对应的数据
	public String getValueByyIndex(int i) {
		return vertexList.get(i);
	}

	// 返回v1和v2的权值
	public int getWeight(int v1, int v2) {
		return edges[v1][v2];
	}

	// 显示图对应的矩阵
	public void showGraph() {
		for (int[] link : edges) {
			System.out.println(Arrays.toString(link));
		}
	}
	/**
	 * 
	 * @Title: getFirstNeighbour
	 * @Description: 返回第一个邻接结点的下标
	 * @param @param index 传入当前的邻接结点的下标
	 * @return int 存在就返回对应的下标，否则返回-1
	 */
	public int getFirstNeighbour(int index) {
		for(int j = 0 ; j<vertexList.size();j++) {
			if(edges[index][j]>0) {
				return j;
			}
		}
		return -1;
	}
	//根据前一个邻接结点的下标返回下一个邻接结点的下标
	public int nextNeighbour(int v1,int v2) {
		for(int j = v2+1;j<vertexList.size();j++) {
			if(edges[v1][j]>0) {
				return j;
			}
		}
		return -1;
	}
	//深度遍历
	public void dfs(boolean[] isVisited,int i) {
		//访问初始顶点i
		System.out.print(getValueByyIndex(i)+"=>");
		//标记第i个顶点被访问
		isVisited[i]=true;
		//查找i的第一个邻接结点w
		int w =getFirstNeighbour(i);
		while(w!=-1) {
			if(!isVisited[w]) {
				//递归访问
				dfs(isVisited, w);
			}
			else {
				//找到与初始顶点邻接的下一个顶点
				w = nextNeighbour(i, w);
			}
		}
	}
	//重载dfs()方法，访问全部顶点，如果有顶点未被访问，则调用dfs(isVisited, i)进行深度遍历
	public void dfs() {
		isVisited = new boolean[vertexList.size()];
		for(int i = 0 ; i <vertexList.size();i++) {
			if(!isVisited[i]) {
				dfs(isVisited, i);
			}
		}
	}
	//广度优先
	public void bfs(boolean[] isVisited,int i) {
		int u;//队列的初始结点
		int w;//邻接结点
		//队列，记录结点访问的顺序
		LinkedList queue = new LinkedList();
		System.out.print(getValueByyIndex(i)+"->");
		isVisited[i] = true;
		queue.addLast(i);
		w = getFirstNeighbour(i);
		while(!queue.isEmpty()) {
			u=(Integer)queue.removeFirst();
			w=getFirstNeighbour(u);
			while(w!=-1) {
				if(!isVisited[w]) {
					System.out.print(getValueByyIndex(w)+"->");
					isVisited[w]=true;
					queue.addLast(w);
				}
				//找到u和w的下一个邻接结点
				w=nextNeighbour(u, w);
				
			}
		}
		
	}
	//遍历所有结点
	public void bfs() {
		isVisited = new boolean[vertexList.size()];
		for(int i = 0 ; i < getNumOfVertex();i++) {
			if(!isVisited[i]) {
				bfs(isVisited, i);
			}
		}
	}
}