图的深度优先遍历算法的递归与非递归JAVA实现

深度优先算法思想

深度优先搜索遍历类似于树的先序遍历。假定给定图G的初态是所有顶点均未被访问过，在G中任选一个顶点i作为遍历的初始点，则深度优先搜索递归调用包含以下操作：

（1）访问搜索到的未被访问的邻接点；

（2）将此顶点的visited数组元素值置1；

（3）搜索该顶点的未被访问的邻接点，若该邻接点存在，则从此邻接点开始进行同样的访问和搜索。

深度优先搜索DFS可描述为：

（1）访问v0顶点；

（2）置 visited[v0]=1；

（3）搜索v0未被访问的邻接点w，若存在邻接点w，则DFS(w)。

遍历过程：     

 DFS 在访问图中某一起始顶点 v 后，由 v 出发，访问它的任一邻接顶点 w1；再从 w1 出发，访问与 w1邻 接但还没有访问过的顶点 w2；然后再从 w2 出发，进行类似的访问，… 如此进行下去，直至到达所有的邻接顶点都被访问过的顶点 u 为止。

接着，退回一步，退到前一次刚访问过的顶点，看是否还有其它没有被访问的邻接顶点。如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问；如果没有，就再退回一步进行搜索。重复上述过程，直到连通图中所有顶点都被访问过为止。如下图所示：
















实现代码

package com.teradata.lsw.sort;

import java.util.Stack;

public class DFS {

// 存储节点信息
private Object[] vertices;
// 存储边的信息数组
private int[][] arcs;
// 边的条数
private int vexnum;
// 记录第i个节点是否被访问过
private boolean[] visited;

//图的初始化
public DFS(int n) {
// TODO Auto-generated constructor stub
vexnum = n;
vertices = new Object
;
arcs = new int

;
visited = new boolean
;
for (int i = 0; i < vexnum; i++) {
for (int j = 0; j < vexnum; j++) {
arcs[i][j] = 0;
}
}

}

/**
* @param args
* 
* @author TD_LSW
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 构建图
DFS g = new DFS(8);
Character[] vertices = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
g.addVertex(vertices);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(3, 5);
g.addEdge(4, 5);
g.addEdge(2, 6);
g.addEdge(2, 7);
System.out.println("深度优先遍历的递归实现：");
g.dfs();
System.out.println();

System.out.println("深度优先遍历的非递归实现：");
g.redfs();
System.out.println();

}

/**
* 深度优先遍历的非递归实现
*/
private void redfs() {
// TODO Auto-generated method stub
//初始化节点遍历的数组
for (int i = 0; i < vexnum; i++) {
visited[i] = false;
}
//定义存储遍历节点的栈
Stack<Integer> s = new Stack<Integer>();
for (int i = 0; i < vexnum; i++) {
if (!visited[i]) {
//未访问的节点入栈
s.add(i);
visited[i] = true;
while (!s.isEmpty()) {
//出栈
int j = s.pop();
System.out.print(vertices[j] + " ");
for (int k = this.lastAdjVex(j); k >= 0; k = this
.lastAdjVex(j, k)) {
if (!visited[k])
s.add(k);
visited[k] = true;
}
}
}
}

}

//往前查找为1的节点
private int lastAdjVex(int i, int k) {
// TODO Auto-generated method stub
for (int j = k - 1; j >= 0; j--) {
if (arcs[i][j] > 0)
return j;
}
return -1;
}

//最深的节点
private int lastAdjVex(int i) {
// TODO Auto-generated method stub
for (int j = vexnum - 1; j >= 0; j--) {
if (arcs[i][j] > 0)
return j;
}
return -1;
}

/**
* 深度优先遍历的递归实现
*/
private void dfs() {
// TODO Auto-generated method stub
//初始化
for (int i = 0; i < vexnum; i++) {
visited[i] = false;
}
//递归实现
for (int i = 0; i < vexnum; i++) {
if (!visited[i])
_dfs(i);
}

}

//遍历节点
private void _dfs(int i) {
// TODO Auto-generated method stub
visited[i] = true;
System.out.print(vertices[i] + " ");
for (int j = this.firstAdjVex(i); j >= 0; j = this.nextAdjVex(i, j)) {
if (!visited[j])
this._dfs(j);
}
}

private int nextAdjVex(int i, int k) {
// TODO Auto-generated method stub
for (int j = k + 1; j < vexnum; j++) {
if (arcs[i][j] > 0)
return j;
}
return -1;
}

//依次查找下一个
private int firstAdjVex(int i) {
// TODO Auto-generated method stub
for (int j = 0; j < vexnum; j++) {
if (arcs[i][j] > 0)
return j;
}
return -1;
}

//边初始化
private void addEdge(int i, int j) {
// TODO Auto-generated method stub
if (i == j)
return;
arcs[i][j] = 1;
arcs[j][i] = 1;
}

//节点初始化
private void addVertex(Object[] obj) {
// TODO Auto-generated method stub
this.vertices = obj;
}

}