精华内容
下载资源
问答
  • 这个项目其实是我的一项课后作业,经过一段时间的努力完成之后,颇有一番收获,所以在此分享,如有不对之处还请各位批评指正! 考虑一个简单的移动机器人,它能够在平面上沿着可以行走的路径移动,并能够记录自身的...
  • 实现的功能是:随机生成迷宫地图和入口,出口位置,然后利用这两种搜索算法自动走出迷宫。用到的工具是C++的MFC,可以看到运动轨迹。 第一次做C++项目,代码优点乱。可以直接运行My_QQ.sln文件。
  • 深度优先算法,图的遍历(c语言)
  • 人工智能的八数码的深度优先算法c++实现
  • 使用Javascript编写的人工智能课程中野人传教士过河问题解决方案脚本,只需使用浏览器打开ai.html即可使用
  • 深度优先算法(DFS 算法)是什么? 寻找起始节点与目标节点之间路径的算法,常用于搜索逃出迷宫的路径。主要思想是,从入口开始,依次搜寻周围可能的节点坐标,但不会重复经过同一个节点,且不能通过障碍节点。如果走...
  • 主要为大家详细介绍了Python深度优先算法生成迷宫,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 采用深度优先算法(DFS)遍历有向无环图寻找最优路径,经过优化的深度优先算法,在遍历有向无环图的时候保存路径,并计算路径权值,最总返回最优路径及最有路径的权值
  • C#深度优先搜索算法

    2020-08-30 04:28:24
    主要介绍了C#深度优先搜索算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 网上大部分解决8数码问题都只采用宽度优先算法。我在宽度优先的基础上,设计出深度优先算法。并制作出界面,方便输入、输出。希望能对学习相关内容的同志有所帮助
  • 深度优先算法

    千次阅读 2017-03-10 15:10:20
    深度优先算法 定义 wiki上的解释: 深度优先搜索算法(英语:Depth-First-Search,简称DFS)是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点v的所在边都己被探寻...

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

    深度优先算法

    定义

    wiki上的解释:

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

    当然看到上面这句话的时候,我并没有理解什么到底是DFS,因此又看了很多人的说话,有了下面一段话: 
    DFS的思想是从一个顶点V0开始,沿着一条路一直走到底,如果发现不能到达目标解,那就返回到上一个节点,然后从另一条路开始走到底。 
    DFS适合此类题目:给定初始状态跟目标状态,要求判断从初始状态到目标状态是否有解。


    深度与广度的比较

    我们搜索一个图是按照树的层次来搜索的。

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

    于是广度优先搜索的缺点出来了:在树的层次较深&子节点数较多的情况下,消耗内存十分严重。广度优先搜索适用于节点的子节点数量不多,并且树的层次不会太深的情况。

    那么深度优先就可以克服这个缺点,因为每次搜的过程,每一层只需维护一个节点。但回过头想想,广度优先能够找到最短路径,那深度优先能否找到呢?深度优先的方法是一条路走到黑,那显然无法知道这条路是不是最短的,所以你还得继续走别的路去判断是否是最短路?

    于是深度优先搜索的缺点也出来了:难以寻找最优解,仅仅只能寻找有解。其优点就是内存消耗小,克服了刚刚说的广度优先搜索的缺点。

    这里写图片描述

    数字为搜索顺序

    代码(转)

    public class DFSTest {
    
            // 存储节点信息
            private char[] vertices;
    
            // 存储边信息(邻接矩阵)
            private  int[][] arcs;
    
            // 图的节点数
            private int vexnum;
    
            // 记录节点是否已被遍历
            private boolean[] visited;
    
            // 初始化
            public DFSTest(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] + " ");
            }
    
            // 从第i个节点开始深度优先遍历
            private 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(){
                // 初始化节点遍历标记
                for (int i = 0; i < vexnum; i++) {
                    visited[i] = false;
                }
    
                // 从没有被遍历的节点开始深度遍历
                for(int i=0;i<vexnum;i++){
                    if(visited[i]==false){
                        // 若是连通图,只会执行一次
                        traverse(i);
                    }
                }
            }
    
            // 图的深度优先遍历(非递归)
            public void DFSTraverse2(){
                // 初始化节点遍历标记
                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);
                        do{ 
                            // 出栈
                            int curr = s.pop();
    
                            // 如果该节点还没有被遍历,则遍历该节点并将子节点入栈
                            if(visited[curr]==false){
                                // 遍历并打印
                                visit(curr);
                                visited[curr] = true;
    
                                // 没遍历的子节点入栈
                                for(int j=vexnum-1; j>=0 ; j-- ){
                                    if(arcs[curr][j]==1 && visited[j]==false){
                                        s.add(j);
                                    }
                                }
                            }
                        }while(!s.isEmpty());
                    }
                }
            }
    
            public static void main(String[] args) {
                DFSTest g = new DFSTest(9);
                char[] vertices = {'A','B','C','D','E','F','G','H','I'};
                g.setVertices(vertices);
    
                g.addEdge(0, 1);
                g.addEdge(0, 5);
                g.addEdge(1, 0);
                g.addEdge(1, 2);
                g.addEdge(1, 6);
                g.addEdge(1, 8);
                g.addEdge(2, 1);
                g.addEdge(2, 3);
                g.addEdge(2, 8);
                g.addEdge(3, 2);
                g.addEdge(3, 4);
                g.addEdge(3, 6);
                g.addEdge(3, 7);
                g.addEdge(3, 8);
                g.addEdge(4, 3);
                g.addEdge(4, 5);
                g.addEdge(4, 7);
                g.addEdge(5, 0);
                g.addEdge(5, 4);
                g.addEdge(5, 6);
                g.addEdge(6, 1);
                g.addEdge(6, 3);
                g.addEdge(6, 5);
                g.addEdge(6, 7);
                g.addEdge(7, 3);
                g.addEdge(7, 4);
                g.addEdge(7, 6);
                g.addEdge(8, 1);
                g.addEdge(8, 2);
                g.addEdge(8, 3);
    
                System.out.print("深度优先遍历(递归):");
                g.DFSTraverse();
    
                System.out.println();
    
                System.out.print("深度优先遍历(非递归):");
                g.DFSTraverse2();
            }
    
    }
    
    
    ----------
    Output:
    深度优先遍历(递归):A B C D E F G H I 
    深度优先遍历(非递归):A B C D E F G H I 
    
           
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170

    博客中有些内容引自: 
    深度优先搜索(DFS)理解DFS概念上很清晰

    展开全文
  • 深度优先算法(DFS)

    万次阅读 2019-04-03 16:54:57
    根据访问节点的顺序与方式,可以分为广度优先算法(BFS)和深度优先算法(DFS),本文介绍深度优先算法深度优先算法 1、算法概述 深度优先搜索属于图算法的一种,英文缩写为DFS。其过程简要来说是对每一个可能的...

    根据访问节点的顺序与方式,可以分为广度优先算法(BFS)和深度优先算法(DFS),本文介绍深度优先算法:

    深度优先算法

    1、算法概述

    深度优先搜索属于图算法的一种,英文缩写为DFS。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止,而且每个节点只能访问一次。

    深度优先搜索是一种在开发爬虫早期使用较多的方法,它的目的是要达到被搜索结构的叶结点(即那些不包含任何超链的HTML文件) 。

    它的思想:
    a.访问顶点v;

    b.依次从v的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v有路径相通的顶点都被访问;

    c.若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止。

    2、原理详解

    (深度优先搜索用栈(stack)来实现,整个过程可以想象成一个倒立的树形)
    1、把根节点压入栈中。

    2、每次从栈中弹出一个元素,搜索所有在它下一级的元素,把这些元素压入栈中。并把这个元素记为它下一级元素的前驱。

    3、找到所要找的元素时结束程序。

    4、如果遍历整个树还没有找到,结束程序。

    本文中,我们使用深度优先算法给图做一个遍历,从而介绍它的原理:

    先给出一个图:
    gei

    假设选定节点A为根节点,将根节点A放入栈中。从栈中取出节点A,寻找到A的子节点B、C并放入栈中。(此时处于节点A)

    从栈中取出节点B,寻找B的子节点D,放入栈中。(此时处于节点B)

    取出节点D,寻找子节点F并放入栈中。

    下一步取出节点F重复执行以上操作,直至遍历全图。

    需要注意的是:

    • 当一个节点有多个子节点,子节点入栈的顺序是随机的,也就是说同样一个图,可以产生多种结果。
    • 走到节点F时,会发现F没有子节点,那么此时就会回跳到F的父节点,并寻找一个尚未走过的节点(若父节点没有尚未走过的子节点,则继续回跳),回跳的过程可以不用表述。

    3、代码描述

    # -*- coding: utf-8 -*-
    """
    Created on Sun Mar 31 16:56:06 2019
    
    @author: King
    """
    
    graph = {
            'A':['B','C'],
            'B':['A','C','D'],
            'C':['A','B','D','E'],
            'D':['B','C','E','F'],
            'E':['C','D'],
            'F':['D']
            }
    
    def DFS(graph,start):
        stack = list(start) #将起始节点放入栈
        closed = set() #创建一个集合,存放已经走过的节点
        closed.add(start)
        while(len(stack)>0):
            vertex = stack.pop() #从栈取出一个节点
            nodes = graph[vertex]
            #判断节点是否走过
            for node in nodes:  
                if node not in closed:
                    #若节点没有走过,则放入栈与集合
                    stack.append(node) 
                    closed.add(node)
            print(vertex,end='\t')
    
    DFS(graph,'A') 
    
    '''
    若以A为根节点,那么遍历的结果可以是:
    A       C       E       D       F       B 
    '''
    
    展开全文
  • 今天小编就为大家分享一篇关于Java基于深度优先遍历的随机迷宫生成算法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 全部功能采用Matlab编写,程序的功能是寻找从出发点到目的地的全部可行路径,最后只显示了最佳和最劣路径的动画效果,对每一步的移动进行了动画演示。
  • 主要介绍了PHP实现深度优先搜索算法(DFS,Depth First Search),简单分析了深度优先搜索算法的原理并结合具体实例给出了php实现深度优先搜索的具体步骤与相关操作技巧,需要的朋友可以参考下
  • 广度优先搜索构建迷宫(BFS算法)动态构建过程的python 源代码,详情请移步本人博客<迷宫与寻路可视化(二)广度优先搜索构建迷宫(BFS算法)>
  • 深度优先算法和广度优先算法(python)

    千次阅读 2019-07-12 12:29:46
    深度优先算法:深度优先搜索算法(Depth-First-Search),是搜索算法的一种。是沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点。这一...

    深度优先算法:深度优先搜索算法(Depth-First-Search),是搜索算法的一种。是沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止。属于盲目搜索
    实现方法:
    在这里插入图片描述
    广度优先算法:广度优先算法(Breadth-First Search),同广度优先搜索,又称作宽度优先搜索,或横向优先搜索,简称BFS,是一种图形搜索演算法。简单的说,BFS(也是一种盲目搜寻法)是从根节点开始,沿着树的宽度遍历树的节点,如果发现目标,则演算终止。广度优先搜索的实现一般采用open-closed表。目的是系统地展开并检查图中的所有节点,以找寻结果。换句话说,它并不考虑结果的可能位置,彻底地搜索整张图,直到找到结果为止。
    实现方法:
    在这里插入图片描述

    算法:

    深度优先:根左右遍历(递归实现)

    def  depth_tree(tree_node):
        if  tree_node   is  not None:
            print(tree_node._data)
            if  tree_node._left is  not None:
                return depth_tree(tree_node._left)
            if  tree_node._right  is  not None:
                return depth_tree(tree_node._right)
    

    广度优先:层次遍历,一层一层的遍历(队列实现)

    def   level_queue(root):
        if  root  is  None:
            pass
        my_queue=[]
        node=root
        my_queue.append(node)   ##根结点入队
        while my_queue:
            node=my_queue.pop(0)  ##出队列
            print(node.elem)      ##访问结点
            if  node.lchild  is  not  None:
                my_queue.append(node.lchild)    ##入队
            if  node.rchild  is  not  None:
                my_queue.append(node.rchild)    ##入队
    

    代码实现:
    在这里插入图片描述
    构建如上图树

    一.列表法:

    用列表构建如上图树:

     my_Tree = [
        'D',  ##根结点
        ['B',
         ['F', [], []],
         ['G', ['E', [], []], []]
         ],  ##左子叶
        ['C',[],
         ['A', ['H', [], []], []]
         ]  ##右子叶
    ]
    

    深度优先

    print(my_Tree[1])
    print(my_Tree[2])
    
    def depth_tree(tree_node):
        if tree_node:
            print(tree_node[0])
            ##访问左子叶
            if tree_node[1]:
    
                depth_tree(tree_node[1])  ##递归遍历
            # ##访问右子叶
            if tree_node[2]:
    
                depth_tree(tree_node[2])  ##递归遍历
    
    depth_tree(my_Tree)
    

    #D B F G E C A H

    在这里插入图片描述

    广度优先:

    def   level_queue(root):
        if  not  root:
            pass
        my_queue=[]
        node=root
        my_queue.append(node)   ##根结点入队
        while my_queue:
            node=my_queue.pop(0)  ##出队列
            print(node[0])      ##访问结点
            if  node[1]:
                my_queue.append(node[1])    ##入队
            if  node[2]:
                my_queue.append(node[2])    ##入队
    level_queue(my_Tree)
    

    #D B F G E C A H

    二.构造类结点法:

    class  Tree:
        root=''
        right=None
        left=None
        ##初始化类
        def __init__(self,node):
            self.root=node
        def set_root(self,node):
            self.root=node
        def get_root(self,node):
            return self.root
    ##初始化树
    a=Tree('A')
    b=Tree('B')
    c=Tree('C')
    d=Tree('D')
    e=Tree('E')
    f=Tree('F')
    g=Tree('G')
    h=Tree('H')
    
    ##根据点的联系,生成关系树
    a.left=h
    b.left=f
    b.right=g
    c.right=a
    d.left=b
    d.right=c
    g.left=e
    

    深度优先:

    def depth_tree(tree_node):
        if tree_node is not None:
            print(tree_node.root)
            if tree_node.left is not None:
                 depth_tree(tree_node.left)      ##递归遍历
            if tree_node.right is not None:
                 depth_tree(tree_node.right)
    ##传入根结点
    depth_tree(d)
    

    在这里插入图片描述
    #D B F G E C A H

    广度优先:

    def   level_queue(root):
        if  root  is  None:
            pass
        my_queue=[]
        node=root
        my_queue.append(node)   ##根结点入队
        while my_queue:
            node=my_queue.pop(0)  ##出队列
            print(node.root)      ##访问结点
            if  node.left  is  not  None:
                my_queue.append(node.left)    ##入队
            if  node.right  is  not  None:
                my_queue.append(node.right)    ##入队
    level_queue(d)
    

    #D B F G E C A H

    展开全文
  • 深度优先算法和广度优先算法

    万次阅读 2018-08-27 22:50:58
    2.深度优先遍历算法 分析深度优先遍历  从图的某个顶点出发,访问图中的所有顶点,且使每个顶点仅被访问一次。这一过程叫做 图的遍历 。 深度优先搜索的思想: ①访问顶点v; ②依次从v的未被访问的...

    参考并感谢Leo_wlCnBlogs

    1.写在前面

    图的存储结构有两种:
    一种是基于二维数组的邻接矩阵表示法。
    另一种是基于链表的的邻接表

    在邻接矩阵中,可以如下表示顶点和边连接关系:
    这里写图片描述这里写图片描述
    说明:
      将顶点对应为下标,根据横纵坐标将矩阵中的某一位置值设为1,表示两个顶点相联接。
      图示表示的是无向图的邻接矩阵,从中我们可以发现它们的分布关于斜对角线对称。
    我们在下面将要讨论的是下图的两种遍历方法(基于矩阵的):
    这里写图片描述这里写图片描述

    #define MaxVnum 50
    typedef double AdjMatrix[MaxVnum][MaxVnum];   //表示一个矩阵,用来存储顶点和边连接关系
    typedef struct {
        int vexnum,arcnum;               //顶点的个数,边的个数
        AdjMatrix arcs;                 //图的邻接矩阵
    }Graph;

    这样我们可以首先来创建上述图,为了方便,我们直接在代码中书写矩阵,而不用每次调试手动输入了

    void CreateGraph(Graph &G)
    {
        G.vexnum=8;
        G.arcnum=9;
        G.arcs[0][1]=1;
        G.arcs[0][2]=1;
        G.arcs[1][3]=1;
        G.arcs[1][4]=1;
        G.arcs[2][5]=1;
        G.arcs[2][6]=1;
        G.arcs[3][1]=1;
        G.arcs[3][7]=1;
        G.arcs[3][6]=1;
        G.arcs[4][1]=1;
        G.arcs[4][7]=1;
        G.arcs[5][2]=1;
        G.arcs[5][6]=1;
        G.arcs[5][5]=1;
        G.arcs[6][2]=1;
        G.arcs[6][5]=1;
        G.arcs[7][3]=1;
        G.arcs[7][4]=1;
    }

    这样我们就已经完成了准备工作,我们可以正式来学习我们的两种遍历方式了。

    2.深度优先遍历算法

    分析深度优先遍历
     从图的某个顶点出发,访问图中的所有顶点,且使每个顶点仅被访问一次。这一过程叫做图的遍历

    深度优先搜索的思想:

    ①访问顶点v;
    ②依次从v的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v有路径相通的顶点都被访问;
    ③若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止。
    比如:
    这里写图片描述
    在这里为了区分已经访问过的节点和没有访问过的节点,我们引入一个一维数组bool visited[MaxVnum]用来表示与下标对应的顶点是否被访问过
    流程:
    ☐ 首先输出 V1,标记V1的flag=true;
    ☐ 获得V1的邻接边 [V2 V3],取出V2,标记V2的flag=true;
    ☐ 获得V2的邻接边[V1 V4 V5],过滤掉已经flag的,取出V4,标记V4的flag=true;
    ☐ 获得V4的邻接边[V2 V8],过滤掉已经flag的,取出V8,标记V8的flag=true;
    ☐ 获得V8的邻接边[V4 V5],过滤掉已经flag的,取出V5,标记V5的flag=true;
    ☐ 此时发现V5的所有邻接边都已经被flag了,所以需要回溯。(左边黑色虚线,回溯到V1,回溯就是下层递归结束往回返)
    这里写图片描述
    ☐ 回溯到V1,在前面取出的是V2,现在取出V3,标记V3的flag=true;
    ☐ 获得V3的邻接边[V1 V6 V7],过滤掉已经flag的,取出V6,标记V6的flag=true;
    ☐ 获得V6的邻接边[V3 V7],过滤掉已经flag的,取出V7,标记V7的flag=true;
    ☐ 此时发现V7的所有邻接边都已经被flag了,所以需要回溯。(右边黑色虚线,回溯到V1,回溯就是下层递归结束往回返)
    深度优先搜索的代码

    bool visited[MaxVnum];
    void DFS(Graph G,int v)
    {
        visited[v]= true; //从V开始访问,flag它
        printf("%d",v);    //打印出V
        for(int j=0;j<G.vexnum;j++) 
            if(G.arcs[v][j]==1&&visited[j]== false) //这里可以获得V未访问过的邻接点
                DFS(G,j); //递归调用,如果所有节点都被访问过,就回溯,而不再调用这里的DFS
    }
    
    void DFSTraverse(Graph G) {
        for (int v = 0; v < G.vexnum; v++)
            visited[v] = false; //刚开始都没有被访问过
    
        for (int v = 0; v < G.vexnum; ++v)
            if (visited[v] == false) //从没有访问过的第一个元素来遍历图
                DFS(G, v);
    }

    3.广度优先搜索算法

    分析广度优先遍历
    所谓广度,就是一层一层的,向下遍历,层层堵截,还是这幅图,我们如果要是广度优先遍历的话,我们的结果是V1 V2 V3 V4 V5 V6 V7 V8。
    这里写图片描述
    广度优先搜索的思想:
    ① 访问顶点vi ;
    ② 访问vi 的所有未被访问的邻接点w1 ,w2 , …wk ;
    ③ 依次从这些邻接点(在步骤②中访问的顶点)出发,访问它们的所有未被访问的邻接点; 依此类推,直到图中所有访问过的顶点的邻接点都被访问;
    说明:
    为实现③,需要保存在步骤②中访问的顶点,而且访问这些顶点的邻接点的顺序为:先保存的顶点,其邻接点先被访问。 这里我们就想到了用标准模板库中的queue队列来实现这种先进现出的服务。
    老规矩我们还是走一边流程:
    说明: 
    ☐将V1加入队列,取出V1,并标记为true(即已经访问),将其邻接点加进入队列,则 <—[V2 V3] 
    ☐取出V2,并标记为true(即已经访问),将其未访问过的邻接点加进入队列,则 <—[V3 V4 V5]
    ☐取出V3,并标记为true(即已经访问),将其未访问过的邻接点加进入队列,则 <—[V4 V5 V6 V7]
    ☐取出V4,并标记为true(即已经访问),将其未访问过的邻接点加进入队列,则 <—[V5 V6 V7 V8]
    ☐取出V5,并标记为true(即已经访问),因为其邻接点已经加入队列,则 <—[V6 V7 V8]
    ☐取出V6,并标记为true(即已经访问),将其未访问过的邻接点加进入队列,则 <—[V7 V8]
    ☐取出V7,并标记为true(即已经访问),将其未访问过的邻接点加进入队列,则 <—[V8]
    ☐取出V8,并标记为true(即已经访问),将其未访问过的邻接点加进入队列,则 <—[]
    广度优先搜索的代码

    #include <queue>
    using namespace std;
    ....
    void BFSTraverse(Graph G)
    {
        for (int v=0;v<G.vexnum;v++) //先将其所有顶点都设为未访问状态
            visited[v]=false;
        queue<int> Q;
        for(int v=0;v<G.vexnum;v++)    
        {
            if(visited[v]==false)   //若该点没有访问
            {
                Q.push(v);    //将其加入到队列中
                visited[v]=true;
                while (!Q.empty())  //只要队列不空,遍历就没有结束
                {
                    int t =Q.front();  //取出对头元素
                    Q.pop();
                    printf(" %d ",t+1);  
                    for(int j=0;j<G.vexnum;j++) //将其未访问过的邻接点加进入队列
                        if(G.arcs[t][j]==1&&visited[j]== false)
                        {
                            Q.push(j);
                            visited[j]=true; //在这里要设置true,因为这里该顶点我们已经加入到了队列,为了防止重复加入!
                        }
                }
            }
        }
    }

    两种算法的复杂度分析

    深度优先
    数组表示:查找所有顶点的所有邻接点所需时间为O(n2),n为顶点数,算法时间复杂度为O(n2)   
    广度优先
    数组表示:查找每个顶点的邻接点所需时间为O(n2),n为顶点数,算法的时间复杂度为O(n2)

    展开全文
  • 深度优先算法: 我的理解 就像走迷宫,每次遇到岔道口就要选一条路来走,每次遇到死胡同就要原路返回找到上一个路口选择其他的路,直到找到出口,显然最坏的情况是遍历完所有的道路后才找到出路,适用于在一个大整体...
  • java 深度优先算法

    2016-01-15 22:34:46
    这是基于java编写的一个深度优先算法,可以实现jar 文件的查阅,控制台能显示转黄的结果
  • 现在我们设定任务为到山东菏泽曹县买牛逼,需要利用深度优先算法(DFS)和广度优先算法(BFS)在中国、省会、市、区县这张大的树中搜索到曹县,那么这个任务Goal就是找到曹县。 假如图的最大路径长度m和最大分支因子b...
  • 通过深度优先算法进行拓扑排序(Java) package graph; //拓扑排序用深度优先算法实现 import java.io.IOException; import java.util.Scanner; import java.util.Stack; public class Topological { private ...
  • 随机迷宫生成算法——深度优先算法

    万次阅读 多人点赞 2018-09-27 21:20:27
    迷宫算法有三大算法:深度优先算法、prim算法和递归分割算法。这里用的是深度优先算法,在此说一下算法思路,希望对各位有所帮助。 首先我的假设是,迷宫只有一条正确的道路。 这个时候请把自己想象成一只地鼠,...
  • 用于解决骑士周游问题的图搜索算法深度优先搜索(DFS),该算法是逐层建立搜索树,沿着树的单支尽量深入的向下搜索。连接尽量多的顶点,必要时可以进行分支。 深度优先搜索同样要用到顶点的“前驱”属性,来构建树...
  • 深度优先算法DFS.cpp

    2021-04-22 08:23:30
    深度优先算法C/C++实现
  • 该代码是DFS算法的实现,讲解部分可以查看我的博客
  • 深度优先搜索的图文介绍 转载自:http://www.cnblogs.com/skywang12345/p/3711483.html 1.深度优先搜索介绍 图的深度优先搜索(Depth First Search),和树的先序遍历比较类似。 它的思想:假设初始状态是图中所有...
  • 主要程序分为画布以及功能区两个部分,其中功能区又具有通过深度优先搜索算法、广度优先算法、贪婪算法、 A* 算法搜索指定节点间最短路径的功能,并且添加了将画布恢复至初始状态的功能。整个程序使用 Python 语言,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 101,201
精华内容 40,480
关键字:

深度优先算法