JAVA實現圖的深度優先遍歷.
阿新 • • 發佈：2018-11-09
一：深度優先遍歷介紹.
1. 深度優先遍歷的定義：
假設圖中的所有的頂點都沒有訪問過,我們是任選一個頂點作為起始出發點(一般選擇使用節點集的第一個元素作為起始頂點).
深度核心思想就是從起始頂點出發,然後一致沿著可以到達的節點走,一條路一直走,直到不可達是,返回到上一個節點,接著走,直到這條路也走不通了,再次返回上一個節點,就這樣,一致遞迴,直到圖中的所有的節點都訪問結束.
2. 深度優先遍歷的特點：
遍歷圖的時候儘可能深的遍歷,一條路走到結束.儘可能去最遠的地方深度優先遍歷結束後會得到一個深度優先佇列,如果沒有指定起始頂點,那麼DFS序列就不唯一,不同的起始頂點得到的DFS序列就不唯一.
消耗記憶體小,可以找到是否有解,難以尋找最優解.
3. 深度優先遍歷的實現方式：
3.1 遞迴實現.
3.2 非遞迴實現.(使用棧).
4. 深度優先遍歷的可以解決的問題模型：
給定初始狀態和目標狀態,從初始狀態判斷到目標狀態是否有解.
用於二叉樹的前中後序遍歷.遞迴版/非遞迴版，在自己秋季校招面試時也手寫過.
二叉樹的先序遍歷(根-左-右).
public List<TreeNode> preIterator(){ return preIterator(root); } private List<TreeNode> preIterator(TreeNode node){ List<TreeNode> list=new ArrayList<TreeNode>(); // 處理根節點 list.add(node); // 遞迴處理左子樹 if(node.left!=null){ list.addAll(preIterator(node.left)); } // 遞迴處理右子樹 if(node.right!=null){ list.addAll(preIterator(node.right)); } return list; }
二. 深度優先遍歷的圖.(15)
如果從節點A開始進行深度優先遍歷：DFS序列為：A B C D E F G H I
三. 程式碼實現.(這裡實現的是從第一個節點開始的DFS序列).遞迴實現.間接明瞭.
1. 定義一位陣列儲存點集.
2. 定義變數指定節點數.
3. 定義Boolean型陣列指定是否訪問的標誌.
4. 定義二維陣列儲存邊的資訊(鄰接矩陣實現).考慮時間複雜度.
5. 初始化DFS.
6. 實現深度優先遍歷的核心程式碼.
public class DFS {
/** 儲存節點資訊*/
private char[] vertices;
/** 儲存邊資訊（鄰接矩陣）*/
private int[][] arcs;
/** 圖的節點數*/
private int vexnum;
/** 記錄節點是否已被遍歷*/
private boolean[] visited;
/** 初始化*/
public DFS(int n) {
vexnum = n;
vertices = new char[n];
arcs = new int[n][n];
visited = new boolean[n];
for (int i = 0; i < vexnum; i++) {
for (int j = 0; j < vexnum; j++) {
arcs[i][j] = 0;
}
}
}
/** 新增邊*/
public void addEdge(int i, int j){
if(i==j){
return ;
}
// 無向圖對稱的.
arcs[i][j]=1;
arcs[j][i]=1;
}
/** 設定節點集*/
public void setVertices(char[] vertices){
this.vertices=vertices;
}
/** 設定節點訪問標記*/
public void setVisited(boolean[] visited){
this.visited=visited;
}
/** 列印遍歷節點*/
public void visit(int i){
System.out.print(vertices[i]+ " ");
}
/**
* 輸出鄰接矩陣
*/
public void pritf(int[][] arcs){
for(int i=0;i<arcs.length;i++){
for(int j=0;j<arcs[0].length;j++){
System.out.print(arcs[i][j]+ "\t");
}
System.out.println();
}
}
/** 從第i節點開始深度優先遍歷*/
public void traverse(int i){
// 標記第i個節點已遍歷
visited[i]=true;
// 列印當前已經遍歷的節點
visit(i);
// 遍歷鄰接矩陣中第i個節點的直接連通節點
for(int j=0;j<vexnum;j++){
if(arcs[i][j]==1&&visited[j]==false){
traverse(j);
}
}
}
public void dfs(){
// 初始化節點訪問標記
for(int i=0;i<visited.length;i++){
visited[i]=false;
}
// 從沒有被遍歷的節點開始深度優先遍歷
for(int i=0;i<vexnum;i++){
// 如果沒有被訪問過.
if(visited[i]==false){
traverse(i);
}
}
// 輸出二維矩陣
System.out.println();
pritf(arcs);
}
public static void main(String[] args) {
DFS dfs = new DFS(9);
// 新增節點集
char[] vertices = {'A','B','C','D','E','F','G','H','I'};
// 設定頂點集
dfs.setVertices(vertices);
// 新增邊
dfs.addEdge(0, 1);
dfs.addEdge(0, 5);
dfs.addEdge(1, 0);
dfs.addEdge(1, 2);
dfs.addEdge(1, 6);
dfs.addEdge(1, 8);
dfs.addEdge(2, 1);
dfs.addEdge(2, 3);
dfs.addEdge(2, 8);
dfs.addEdge(3, 2);
dfs.addEdge(3, 4);
dfs.addEdge(3, 6);
dfs.addEdge(3, 7);
dfs.addEdge(3, 8);
dfs.addEdge(4, 3);
dfs.addEdge(4, 5);
dfs.addEdge(4, 7);
dfs.addEdge(5, 0);
dfs.addEdge(5, 4);
dfs.addEdge(5, 6);
dfs.addEdge(6, 1);
dfs.addEdge(6, 3);
dfs.addEdge(6, 5);
dfs.addEdge(6, 7);
dfs.addEdge(7, 3);
dfs.addEdge(7, 4);
dfs.addEdge(7, 6);
dfs.addEdge(8, 1);
dfs.addEdge(8, 2);
dfs.addEdge(8, 3);
System.out.print("深度優先遍歷（遞迴實現）：");
dfs.dfs();
}
}執行結果如下：
非遞迴實現.基於棧實現.
import java.util.Stack;
/**
* title： com.lx.algorithm.graph
* @author： lixing
* date： 2018/10/31 21:03
* description：
*/
public class DFSStack {
/** 儲存節點資訊*/
private char[] vertices;
/** 儲存邊資訊（鄰接矩陣）*/
private int[][] arcs;
/** 圖的節點數*/
private int vexnum;
/** 記錄節點是否已被遍歷*/
private boolean[] visited;
/** 初始化*/
public DFSStack(int n) {
vexnum = n;
vertices = new char[n];
arcs = new int[n][n];
visited = new boolean[n];
for (int i = 0; i < vexnum; i++) {
for (int j = 0; j < vexnum; j++) {
arcs[i][j] = 0;
}
}
}
/** 新增邊*/
public void addEdge(int i, int j){
if(i==j){
return ;
}
// 無向圖對稱的.
arcs[i][j]=1;
arcs[j][i]=1;
}
/** 設定節點集*/
public void setVertices(char[] vertices){
this.vertices=vertices;
}
/** 設定節點訪問標記*/
public void setVisited(boolean[] visited){
this.visited=visited;
}
/** 列印遍歷節點*/
public void visit(int i){
System.out.print(vertices[i]+ " ");
}
/**
* 輸出鄰接矩陣
*/
public void pritf(int[][] arcs){
for(int i=0;i<arcs.length;i++){
for(int j=0;j<arcs[0].length;j++){
System.out.print(arcs[i][j]+ "\t");
}
System.out.println();
}
}
public void dfs(){
// 初始化所有的節點的訪問標誌
for (int v = 0; v < visited.length; v++) {
visited[v] = false;
}
Stack<Integer> stack =new Stack<Integer>();
for(int i=0;i<vexnum;i++){
if(visited[i]==false){
visited[i]=true;
System.out.print(vertices[i]+" ");
stack.push(i);
}
while(!stack.isEmpty()){
// 當前出棧的節點
int k = stack.pop();
for(int j=0;j<vexnum;j++){
// 如果是相鄰的節點且沒有訪問過.
if(arcs[k][j]==1&&visited[j]==false){
visited[j]=true;
System.out.print(vertices[j]+" ");
stack.push(j);
// 這條路結束,返回上一個節點.
break;
}
}
}
}
// 輸出二維矩陣
System.out.println();
pritf(arcs);
}
public static void main(String[] args) {
DFSTest dfs = new DFSTest(9);
// 新增節點集
char[] vertices = {'A','B','C','D','E','F','G','H','I'};
// 設定頂點集
dfs.setVertices(vertices);
// 新增邊
dfs.addEdge(0, 1);
dfs.addEdge(0, 5);
dfs.addEdge(1, 0);
dfs.addEdge(1, 2);
dfs.addEdge(1, 6);
dfs.addEdge(1, 8);
dfs.addEdge(2, 1);
dfs.addEdge(2, 3);
dfs.addEdge(2, 8);
dfs.addEdge(3, 2);
dfs.addEdge(3, 4);
dfs.addEdge(3, 6);
dfs.addEdge(3, 7);
dfs.addEdge(3, 8);
dfs.addEdge(4, 3);
dfs.addEdge(4, 5);
dfs.addEdge(4, 7);
dfs.addEdge(5, 0);
dfs.addEdge(5, 4);
dfs.addEdge(5, 6);
dfs.addEdge(6, 1);
dfs.addEdge(6, 3);
dfs.addEdge(6, 5);
dfs.addEdge(6, 7);
dfs.addEdge(7, 3);
dfs.addEdge(7, 4);
dfs.addEdge(7, 6);
dfs.addEdge(8, 1);
dfs.addEdge(8, 2);
dfs.addEdge(8, 3);
System.out.print("深度優先遍歷（非遞迴實現）：");
dfs.dfs();
}
}執行結果:
至此完成基於JAVA的深度優先遍歷實現.