深度优先遍历(DFS)

 图的深度优先搜索(Depth First Search) 。

1)深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。

2)我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。显然，深度优先搜索是一个递归的过程

深度优先遍历算法步骤

1)访问初始结点v，并标记结点v为已访问。

2)查找结点v的第一个邻接结点w。

3)若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。

4)若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。

5)查找结点v的w邻接结点的下一个邻接结点，转到步骤3。

package com.zhen;

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

public class Graph {
	//存放顶点
	private ArrayList<String> dot;
	//存放邻接矩阵
	private int[][] edge;
	//边的数量
	private int count=0;
	//节点的访问标识
	private boolean[] mark;
	
	public static void main(String[] args) {
		int n=5;
		String[] dot= {"A","B","C","D","E"};
		Graph graph = new Graph(5);
		//添加点
		for(String s:dot) {
			graph.addDot(s);
		}
		//添加边
		graph.adddEdge(0, 1, 1);
		graph.adddEdge(0, 2, 1);
		graph.adddEdge(1, 2, 1);
		graph.adddEdge(1, 3, 1);
		graph.adddEdge(1, 4, 1);
		
		graph.show();
		System.out.println("DFS");
		graph.dfs();
	}
	
	//初始化
	public Graph(int n) {
		edge=new int[n][n];
		dot = new ArrayList<String>(n);
		mark = new boolean[n];
	}
	//插入节点
	public void addDot(String s) {
		dot.add(s);
	}
	/**
	 * 添加边
	 * @param row  行节点的下标
	 * @param col  列节点的下标
	 * @param value  权值
	 */
	public void adddEdge(int row,int col,int value) {
		edge[row][col]=value;
		edge[col][row]=value;
		count++;
	}
	//获取节点个数
	public int getDotNum() {
		return dot.size();
	}
	//获取边的数目
	public int getEdgeNum() {
		return count;
	}
	//返回节点i(下标)对应的点名称  0->A,1->B,2->C...
	public String getS(int i) {
		return dot.get(i);
	}
	//返回权值
	public int getValue(int row,int col) {
		return edge[row][col];
	}
	//显示图对应的矩阵
	public void show() {
		for(int[] link:edge) {
			System.out.println(Arrays.toString(link));
		}
	}
	//得到第一个邻接节点的下标
	public int getFindex(int index) {
		for (int i = 0; i < dot.size(); i++) {
			if (edge[index][i]>0) {
				return i;
			}
		}
		return -1;
	}
	//根据前一个邻接节点的下标获取下一个邻接节点
	public int getNext(int row,int col) {
		for(int j=col+1;j<dot.size(); j++) {
			if (edge[row][j]>0) {
				return j;
			}
		}
		return -1;
	}
	//深度优先遍历,i第一次就是0
	public void dfs(boolean[] mark,int i) {
		//首先访问该节点并输出
		System.out.print(getS(i)+"->");
		//将该节点设为已访问
		mark[i]=true;
		//查找节点i的第一个邻接节点w
		int w=getFindex(i);
		//有
		while(w!=-1) {
			//未被访问过
			if (!mark[w]) {
				dfs(mark, w);
			}
			//访问过就去找下一个邻接节点
			w=getNext(i, w);
		}
	}
	//重载DFS遍历所有节点
	public void dfs() {
		for (int i = 0; i <getDotNum();i++) {
			if (!mark[i]) {
				dfs(mark, i);
			}
		}
	}
}