深度优先算法dfs_根据一个起始点写出深度优先序列

转载https://blog.csdn.net/u014394715/article/details/51192293

 

 

深度优先算法

定义

深度优先搜索算法（英语：Depth-First-Search，简称DFS）是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜索。

简单来说
DFS的思想是从一个顶点V0开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底。 

 

深度与广度的比较

案列：搜索一个图是按照树的层次来搜索的。

我们假设一个节点衍生出来的相邻节点平均的个数是N个，那么当起点开始搜索的时候，队列有一个节点，当起点拿出来后，把它相邻的节点放进去，那么队列就有N个节点，当下一层的搜索中再加入元素到队列的时候，节点数达到了N2，你可以想想，一旦N是一个比较大的数的时候，这个树的层次又比较深，那这个队列就得需要很大的内存空间了。

广度优先搜索

• 缺点：在树的层次较深并且子节点数较多的情况下，消耗内存十分严重。
• 优点：能够找到最短路径
• 适用范围：适用于节点的子节点数量不多，并且树的层次不会太深的情况。

深度优先搜索

优点：内存消耗小，克服广度优先搜索的缺点。因为每次搜的过程，每一层只需维护一个节点

缺点：难以寻找最优解，仅仅只能寻找有解

 

代码

package Test;
 
import java.util.Stack;
 
public class DFSTest {
 
        // 存储节点信息
        private char[] vertices;
 
        // 存储边信息（邻接矩阵）
        private  int[][] arcs;
 
        // 图的节点数
        private int vexnum;
 
        // 记录节点是否已被遍历
        private boolean[] visited;
 
        // 初始化
        public DFSTest(int[][] arcs,char[] vertices) {
        	//图的节点数
              vexnum = arcs.length;
          	//存储节点信息
              this.vertices = vertices;
              //记录节点是否已被遍历,默认false,数组下标对应相应节点
              visited = new boolean[vexnum];
            //存储边信息（邻接矩阵） 
             this.arcs = arcs;
        }
 
        // 打印遍历节点
        public void visit(int i){
            System.out.print(vertices[i] + " ");
        }
 
        // 从第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 DFSTraverse(){
        	// 初始化节点遍历标记,默认设置没有访问
            visited=new boolean[vexnum];
            
            // 从没有被遍历的节点开始深度遍历
            for(int i=0;i<vexnum;i++){
                if(visited[i]==false){
                    // 若是连通图，只会执行一次
                    traverse(i);
                }
            }
        }
 
        // 图的深度优先遍历（非递归）
        public void DFSTraverse2(){
            // 初始化节点遍历标记,默认设置没有访问
            visited=new boolean[vexnum];
             
            Stack<Integer> s = new Stack<Integer>();
            
            for(int i=0;i<vexnum;i++){
                if(!visited[i]){//如果当前节点没有访问过,添加到栈中
                    //连通子图起始节点
                    s.add(i);
                    do{ 
                        // 出栈
                        int curr = s.pop();
                        // 如果该节点还没有被遍历，则遍历该节点并将相邻节点入栈
                        if(visited[curr]==false){
                            // 遍历并打印
                            visit(curr);
                            //设置该节点以访问
                            visited[curr] = true;
                            // 没遍历的相邻节点入栈(先进后出)
                          for(int j=vexnum-1; j>=0 ; j-- ){
                            	//当前节点的相邻节点，且是没有访问过d
                                if(arcs[curr][j]==1 && visited[j]==false){
                                    s.add(j);
                                }
                            }
                        }
                    }while(!s.isEmpty());
                }
            }
        }
 
        public static void main(String[] args) {
            
            char[] vertices = {'A','B','C','D','E','F','G','H','I'};
            
            int[][] arcs ={ 
            		{0,1,0,0,0,1,0,0,0}, //A节点的相邻节点设置1
            		{1,0,1,0,0,0,1,0,1},  //B节点的相邻节点设置1
            		{0,1,0,1,0,0,0,0,1},  //C节点的相邻节点设置1
            		{0,0,1,0,1,0,1,1,1}, //D节点的相邻节点设置1
            		{0,0,0,1,0,1,0,1,0},  //E节点的相邻节点设置1
            		{1,0,0,0,1,0,1,0,0},  //F节点的相邻节点设置1
            		{0,1,0,1,0,1,0,1,0},  //G节点的相邻节点设置1
            		{0,0,0,1,1,0,1,0,0},  //H节点的相邻节点设置1
            		{0,1,1,1,0,0,0,0,0},  //I节点的相邻节点设置1
                };
            DFSTest g = new DFSTest(arcs,vertices);
            
           
          
 
            System.out.print("深度优先遍历（递归）：");
            g.DFSTraverse();
 
            System.out.println();
 
            System.out.print("深度优先遍历（非递归）：");
            g.DFSTraverse2();
        }
 
}
 

 

 测试结果：

深度优先遍历（递归）：A B C D E F G H I 
深度优先遍历（非递归）：A B C D E F G H I