日撸Java三百行（day34：图的深度优先遍历）

一、深度优先搜索

二、图的深度优先遍历

三、代码实现

总结

一、深度优先搜索

深度优先搜索（Depth First Search：DFS）是一种用于遍历树或图的算法，具体来说就是从起始节点开始，沿某一分支路径不断深入，直到无法再深入时回溯并探索其他分支。

补充：

回溯法，又称试探法，是一种选优搜索法，它的基本思想是根据选优条件向前搜索，以达到目标。当探索到某一步发现原选择并不优或达不到目标时，就回退到上一步重新选择，这种走不通就退回重走的方法即为回溯法，而满足回溯条件的点（即可以退回重新进行选择的点）就称为回溯点。

需要注意，回溯操作往往发生在某一路径不能再继续深入时，且回溯并不是回到起始位置，而是回退到上一步。

二、图的深度优先遍历

所谓图的深度优先遍历就是按照深度优先搜索的方式对图进行遍历，且每个节点（顶点）只能访问一次，为了更直观地理解深度优先遍历的整个过程，我们以下图为例进行说明。

我们将节点a作为起始节点，然后从a开始深度优先遍历，具体如下：

第一步，从节点a出发，选择一条分支路径不断深入，这里我们选择的是b-c-d分支，如下图1。

此时得到访问顺序为a-b-c-d，如下图2。

第二步，到达节点d后发现无法再继续深入，于是开始回溯，回溯到节点c后重新选择节点c的另一条分支路径e开始深入，如下图3。

此时得到访问顺序为a-b-c-d-e，如下图4。

第三步，访问节点e之后，发现节点e的唯一分支b节点已经被访问，于是回溯到节点c；回溯到节点c之后，发现节点c的两个分支均已经被访问，于是继续回溯到节点b；回溯到节点b之后，发现节点b的唯一分支节点c也已经被访问过了，于是再次回溯；回溯到节点a之后，重新选择节点a的另一分支f开始深入，如下图5。

此时得到访问顺序为a-b-c-d-e-f-g，如下图6。

第四步，访问节点g之后，发现节点g的唯一分支节点e已经被访问，于是回溯到节点f；回溯到节点f之后，发现节点f的唯一分支节点g也已经被访问，于是继续回溯到节点a；回溯到节点a之后，发现节点a的两个分支均已经被访问，于是再次回溯；发现已经没有节点可以回溯了，遍历结束。

因此，最终的遍历顺序就是a-b-c-d-e-f-g。

根据以上分析，我们可以把DFS的过程总结为三大步：

第一步，访问当前节点。
第二步，如果当前节点存在未被访问的邻接节点，就进入该邻接节点（即把该邻接节点作为新的当前节点），并返回第一步。
第三步，如果当前节点不存在未被访问的邻接节点，就回溯到上一个节点（即把上一个节点作为新的当前节点），并返回第二步。

此外，在上述遍历的过程中可以发现，有时候会到达已经被访问过的节点，因此为了避免重复访问，我们可以使用一个访问数组来标记节点是否被访问。

在深度优先遍历的过程中，我们需要进行回溯，即需要暂存节点信息以便后续操作使用，因此很容易想到利用栈来实现，之前入栈的元素进行出栈即可达到回溯的目的。下面我们就用栈来模拟一下上述例子的深度优先遍历，具体如下：

访问节点a；a存在未被访问的邻接节点，于是将a入栈。
寻找节点a的未被访问的邻接节点，找到了节点b。
访问节点b；b存在未被访问的邻接节点c，于是将b入栈。
寻找节点b的未被访问的邻接节点，找到了节点c。
访问节点c；c存在未被访问的邻接节点d，于是将c入栈。
寻找节点c的未被访问的邻接节点，找到了节点d。
访问节点d；d不存在未被访问的邻接节点，所以d不入栈，将当前栈顶元素c出栈。
寻找当前出栈元素c的未被访问的邻接节点，找到了节点e。
访问节点e；e不存在未被访问的邻接节点，所以e不入栈，将当前栈顶元素b出栈。
寻找当前出栈元素b的未被访问的邻接节点，没有找到，继续将当前栈顶元素a出栈。
寻找当前出栈元素a的未被访问的邻接节点，找到了节点f。
访问节点f；f存在未被访问的邻接节点，于是将f入栈。
寻找节点f的未被访问的邻接节点，找到了节点g。
访问节点g；g不存在未被访问的邻接节点，所以g不入栈，将当前栈顶元素出栈。
但由于此时栈已空，于是遍历结束。

最后得到遍历顺序为a-b-c-d-e-f-g，与之前保持一致。因此，如果用栈来实现，那么我们之前总结的三大步就可以修改为：

第一步，访问当前节点。
第二步，如果该当前节点存在未被访问的邻接节点，则将该当前节点入栈，并把它的未被访问的邻接节点作为新的当前节点，返回第一步。
第三步，如果该当前节点不存在未被访问的邻接节点，则将当前栈顶元素出栈，并寻找该出栈元素的未被访问的邻接节点。如果找到了，则将找到的这个节点作为新的当前节点，返回第一步；如果没有找到，就再次将当前栈顶元素出栈，重新执行第三步。

三、代码实现

大致理清楚图的深度优先遍历后，我们开始代码实现。

首先是一些基本准备工作，包括创建一个通用性栈，用于暂存节点以及创建一个布尔类型的访问数组，用于记录节点是否被访问，如下：

ObjectStack tempStack = new ObjectStack();
String resultString = "";
		
int tempNumNodes = connectivityMatrix.getRows();
boolean[] tempVisitedArray = new boolean[tempNumNodes];

然后，访问起始节点，将访问数组中起始节点对应的元素赋值为true，并将起始节点入栈，如下：

// Initialize the stack.
// Visit before push.
tempVisitedArray[paraStartIndex] = true;
resultString += paraStartIndex;
tempStack.push(new Integer(paraStartIndex));
System.out.println("Push " + paraStartIndex);
System.out.println("Visited " + resultString);

接着，开始遍历剩余节点，具体如下：

        // Now visit the rest of the graph.
		int tempIndex = paraStartIndex;
		int tempNext;
		Integer tempInteger;
		while (true){
		// Find an unvisited neighbor.
			tempNext = -1;
			for (int i = 0; i < tempNumNodes; i++) {
				if (tempVisitedArray[i]) {
					continue; // Already visited.
				} // Of if
				
				if (connectivityMatrix.getData()[tempIndex][i] == 0) {
					continue; // Not directly connected.
				} // Of if
				
				// Visit this one.
				tempVisitedArray[i] = true;
				resultString += i;
				tempStack.push(new Integer(i));
				System.out.println("Push " + i);
				tempNext = i;
				
				// One is enough.
				break;
			} // Of for i
			
			if (tempNext == -1) {
				tempInteger = (Integer) tempStack.pop();
				System.out.println("Pop " + tempInteger);
				if (tempStack.isEmpty()) {
					// No unvisited neighbor. Backtracking to the last one
					// stored in the stack.
					// Attention: This is the terminate condition!
					break;
				} else {
					// Back to the previous node, however do not remove it.
					tempInteger = (Integer) tempStack.pop();
					tempIndex = tempInteger.intValue();
					tempStack.push(tempInteger);
				} // Of if
			} else {
				tempIndex = tempNext;
			} // Of if
		} // Of while
		
		return resultString;

tempIndex代表当前栈顶元素，由于我们之前仅将起始节点入栈，所以此时的栈顶元素即为起始节点；然后我们进入for循环，去寻找当前节点的未被访问的邻接（直接相连）节点，在该for循环中第一个if语句用于排除已经被访问的节点，第二个if语句用于排除非邻接（直接相连）的节点，一旦找到后立马访问该节点，将访问数组中该节点对应的元素赋值为true，并将该节点入栈；tempNext代表当前未被访问的邻接节点，tempNext=-1时表示此时不存在未被访问的邻接节点，于是将当前的栈顶元素出栈。

然后，照例为该方法写一个单元测试，如下：

    /**
	 *********************
	 * Unit test for depthFirstTraversal.
	 *********************
	 */
	public static void depthFirstTraversalTest() {
		// Test an undirected graph.
		int[][] tempMatrix = { { 0, 1, 1, 0 }, { 1, 0, 0, 1 }, { 1, 0, 0, 0}, { 0, 1, 0, 0} };
		Graph tempGraph = new Graph(tempMatrix);
		System.out.println(tempGraph);

		String tempSequence = "";
		try {
			tempSequence = tempGraph.depthFirstTraversal(0);
		} catch (Exception ee) {
			System.out.println(ee);
		} // Of try.

		System.out.println("The depth first order of visit: " + tempSequence);
	} // Of depthFirstTraversalTest

完整的程序代码：

    /**
	 *********************
	 * Depth first traversal.
	 * 
	 * @param paraStartIndex The start index.
	 * @return The sequence of the visit.
	 *********************
	 */
	public String depthFirstTraversal(int paraStartIndex) {
		ObjectStack tempStack = new ObjectStack();
		String resultString = "";
		
		int tempNumNodes = connectivityMatrix.getRows();
		boolean[] tempVisitedArray = new boolean[tempNumNodes];
		
		// Initialize the stack.
		// Visit before push.
		tempVisitedArray[paraStartIndex] = true;
		resultString += paraStartIndex;
		tempStack.push(new Integer(paraStartIndex));
		System.out.println("Push " + paraStartIndex);
		System.out.println("Visited " + resultString);
		
		// Now visit the rest of the graph.
		int tempIndex = paraStartIndex;
		int tempNext;
		Integer tempInteger;
		while (true){
		// Find an unvisited neighbor.
			tempNext = -1;
			for (int i = 0; i < tempNumNodes; i ++) {
				if (tempVisitedArray[i]) {
					continue; // Already visited.
				} // Of if
				
				if (connectivityMatrix.getData()[tempIndex][i] == 0) {
					continue; // Not directly connected.
				} // Of if
				
				// Visit this one.
				tempVisitedArray[i] = true;
				resultString += i;
				tempStack.push(new Integer(i));
				System.out.println("Push " + i);
				tempNext = i;
				
				// One is enough.
				break;
			} // Of for i
			
			if (tempNext == -1) {
				tempInteger = (Integer) tempStack.pop();
				System.out.println("Pop " + tempInteger);
				if (tempStack.isEmpty()) {
					// No unvisited neighbor. Backtracking to the last one
					// stored in the stack.
					// Attention: This is the terminate condition!
					break;
				} else {
					// Back to the previous node, however do not remove it.
					tempInteger = (Integer) tempStack.pop();
					tempIndex = tempInteger.intValue();
					tempStack.push(tempInteger);
				} // Of if
			} else {
				tempIndex = tempNext;
			} // Of if
		} // Of while
		
		return resultString;
	} // Of depthFirstTraversal
	
	/**
	 *********************
	 * Unit test for depthFirstTraversal.
	 *********************
	 */
	public static void depthFirstTraversalTest() {
		// Test an undirected graph.
		int[][] tempMatrix = { { 0, 1, 1, 0 }, { 1, 0, 0, 1 }, { 1, 0, 0, 0}, { 0, 1, 0, 0} };
		Graph tempGraph = new Graph(tempMatrix);
		System.out.println(tempGraph);

		String tempSequence = "";
		try {
			tempSequence = tempGraph.depthFirstTraversal(0);
		} catch (Exception ee) {
			System.out.println(ee);
		} // Of try.

		System.out.println("The depth first order of visit: " + tempSequence);
	} // Of depthFirstTraversalTest

	/**
	 *********************
	 * The entrance of the program.
	 * 
	 * @param args Not used now.
	 *********************
	 */
	public static void main(String args[]) {
		System.out.println("Hello!");
		Graph tempGraph = new Graph(3);
		System.out.println(tempGraph);

		// Unit test.
		getConnectivityTest();
		
		breadthFirstTraversalTest();

		depthFirstTraversalTest();
	} // Of main

运行结果：

总结

深度优先搜索DFS，简称深搜，是一种非常常见的算法，与广度优先搜索并称两大优先搜索算法，它具有广泛的实用性，不仅可以用来遍历树或图，还可以查找连通分量、实现拓扑排序、解决迷宫问题，并且在人工智能领域常和剪枝策略结合使用以提高在状态空间中搜索解决方案的效率。

图的深度优先遍历简言之就是先访问当前节点，然后不断搜索当前节点的未被访问的邻接节点，直到无法搜索到时开始回溯，显然这种模式下后访问的节点，它的邻接节点会先被访问，因此我们可以借助栈“后进先出”的特性来完成，当然也可以使用递归来实现。其实，如果仔细思考就会发现，图的深度优先遍历思想就是树的前序遍历思想。