Python宽搜（BFS）和深搜（DFS）

最新推荐文章于 2024-05-02 00:08:34 发布
最新推荐文章于 2024-05-02 00:08:34 发布
阅读量4.5k 收藏 98
点赞数 17
分类专栏： python学习笔记 蓝桥杯 文章标签： 深度优先 python 宽度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45758642/article/details/122945316
版权

目录

BFS

BFS是什么

BFS称为宽度优先搜索也叫做广度优先搜索，其别名又叫BFS，属于一种盲目搜寻法。
Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。
目的是系统地展开并检查图中的所有节点，以找寻结果。
换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。
它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。
广度优先搜索使用队列（queue）来实现，队列(queue)有着先进先出FIFO(First Input First Output)的特性。

BPS工作过程和原理

BFS操作步骤如下：
1、把起始点放入queue；
2、重复下述2步骤，直到queue为空为止：
1）从queue中取出队列队首；
2）找出与此点邻接的且尚未遍历的点，进行标记，然后全部放入queue中。

（1）将起始节点1放入队列中，标记为已遍历：
这里写图片描述

（2）从queue中取出队列头的节点1，找出与节点1邻接的节点2,3，标记为已遍历，然后放入queue中。
这里写图片描述

（3）从queue中取出队列头的节点2，找出与节点2邻接的节点1,4,5，由于节点1已遍历，排除；标记4,5为已遍历，然后放入queue中。
这里写图片描述

（4）从queue中取出队列头的节点3，找出与节点3邻接的节点1,6,7，由于节点1已遍历，排除；标记6,7为已遍历，然后放入queue中。
这里写图片描述

（5）从queue中取出队列头的节点4，找出与节点4邻接的节点2,8，2属于已遍历点，排除；因此标记节点8为已遍历，然后放入queue中。
这里写图片描述

（6）从queue中取出队列头的节点5，找出与节点5邻接的节点2,8，2,8均属于已遍历点，不作下一步操作。
这里写图片描述

（7）从queue中取出队列头的节点6，找出与节点6邻接的节点3,8,9，3,8属于已遍历点，排除；因此标记节点9为已遍历，然后放入queue中。
这里写图片描述

（8）从queue中取出队列头的节点7，找出与节点7邻接的节点3, 9，3,9属于已遍历点，不作下一步操作。
这里写图片描述

（9）从queue中取出队列头的节点8，找出与节点8邻接的节点4,5,6，4,5,6属于已遍历点，不作下一步操作。
这里写图片描述

（10）从queue中取出队列头的节点9，找出与节点9邻接的节点6,7，6,7属于已遍历点，不作下一步操作。
这里写图片描述
（11）queue为空，BFS遍历结束。

BFS应用场景

  • BFS的两个场景：层序遍历、最短路径
  • 找距离某一点的最短路，但路径不唯一，最先搜索到满足条件的就是最短的路径
  • 大范围的查找
  • 出现 “最短”、“最少”类似字眼的可以优先考虑

python实现BFS（树和图）

树是特殊的图

python实现BFS图

在这里插入图片描述

import os
import sys

'''
python实现BFS的图
2022-01-15
'''

# 创建一个字典，用于存储图。字典相当于映射关系，通过键值对进行读取。适用于图只有少量的点，数据过多使用python类更为合适
graph = {
    "A": ["B", "C"],
    "B": ["A", "C", "D"],
    "C": ["A", "B", "D", "E"],
    "D": ["B", "C", "E", "F"],
    "E": ["C", "D"],
    "F": ["D"]
}

# 开始BFS遍历
# graph是图数据，s是图的起点
def BFS(graph, s):
    # 创建一个数组作为队列，用于存储未访问过的点
    queue = []
    # 放入起点
    queue.append(s)
    # 创建一个集合，用于存放已读入的点，例如起点s
    seen = set()
    seen.add(s)
    # 循环读queue
    while (len(queue) > 0):
        # 通过queue.pop(0)读取队列队首,即每个点
        vertex = queue.pop(0)
        # 读取每个点相邻的点
        nodes = graph[vertex]
        # 判重：循环判断相邻的点是否读过
        for w in nodes:
            if w not in seen:
                queue.append(w)
                seen.add(w)
        # 输出遍历节点
        print(vertex, end= ' ')

BFS(graph, "A")
'''
# 运行结果
A B C D E F
'''

python实现图的最短路径

在这里插入图片描述
由上面的代码改进而来

import os
import sys

'''
python实现BFS的图
2022-01-15
'''

# 创建一个字典，用于存储图。字典相当于映射关系，通过键值对进行读取。适用于图只有少量的点，数据过多使用python类更为合适
graph = {
    "A": ["B", "C"],
    "B": ["A", "C", "D"],
    "C": ["A", "B", "D", "E"],
    "D": ["B", "C", "E", "F"],
    "E": ["C", "D"],
    "F": ["D"]
}

# 开始BFS遍历
# graph是图数据，s是图的起点
def BFS(graph, s):
    # 创建一个数组作为队列，用于存储未访问过的点
    queue = []
    # 放入起点
    queue.append(s)
    # 创建一个集合，用于存放已读入的点，例如起点s
    seen = set()
    seen.add(s)
    # 路径还原，把访问的点和它前一个点对应起来，形成一个键值对，利用它来完成最短路径的输出
    parent = {s: None}
    # 循环读queue
    while (len(queue) > 0):
        # 通过queue.pop(0)读取队列队首,即每个点
        vertex = queue.pop(0)
        # 读取每个点相邻的点
        nodes = graph[vertex]
        # 判重：循环判断相邻的点是否读过
        for w in nodes:
            if w not in seen:
                queue.append(w)
                seen.add(w)
                parent[w] = vertex
        # 输出遍历节点
        # print(vertex, end= ' ')
    return parent


parent = BFS(graph, "A")
# 输出你想要的到最短路径
# 设v为终点
v = 'F'
# 循环查找v
while v != None:
    print(v, end=' ')
    v = parent[v]
'''
# 运行结果
F D B A 
'''

python实现BFS树

在这里插入图片描述

# 定义一个树的节点
class TreeNode:
    def __init__(self, x):
        self.val = x  # 值
        self.left = None  # 左节点
        self.right = None  # 右节点


def level_order_tree(root):
    if not root:  # 一个树只有根节点，返回空值
        return root
    queue = []
    result = []
    queue.append(root)  # 将根节点入队
    result.append(root.val)  # 添加根节点值
    while len(queue) > 0:
        node = queue.pop(0)  # 取队列队首
        result.append(node.val)
        # 判断左右子树
        if node.left:  # 添加左子树的孩子到队列
            queue.append(node.left)
        if node.right:  # 添加右子树的孩子到队列
            queue.append(node.right)
    return result


if __name__ == "__main__":
    tree = TreeNode(4)
    tree.left = TreeNode(9)
    tree.right = TreeNode(0)
    tree.left.left = TreeNode(5)
    tree.left.right = TreeNode(1)

    print(level_order_tree(tree))
    # [4, 9, 0, 5, 1, 3, 2, 10, 7]

DFS

DFS是什么

  1. 深度优先搜索算法（英语：Depth-First-Search，简称DFS）是一种用于遍历或搜索树或图的算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。
  2. 当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。
  3. 对于同一颗的树或图，其DFS序不一定唯一。
  4. 深度优先搜索使用栈（stack）来实现，栈(stack)有着先进后出的特性。

DFS工作过程和原理

DFS工作过程和原理
在这里插入图片描述
请不要忘记DFS序不一定唯一。

  1. 以A为开始节点，访问A，与A相连的邻接点有B和C。
  2. 此时可以访问B和C，访问哪个取决于你压栈的顺序。
  3. 访问B，与B相连的邻接点有C和D。
  4. 访问D，与D相连的邻接点有E和F。
  5. 访问F，F没有邻接点，原路返回来时最近的邻接点D。
  6. 与D相连的邻接点E没被访问过，访问E，与E相连的邻接点有C和D。
  7. 访问C，C的邻接点有A、B、D和E，全被访问过了，原路返回D，此时D的邻接点都被访问过了，原路返回B，再到A。

DFS应用场景

  • 求子序列、求子集
  • 找所有可能的解决方案，逐层组装结果（跟第一种没太大差别）

python实现DFS

python实现DFS图

import os
import sys

'''
python实现DFS的图
2022-01-15
'''

# 创建一个字典，用于存储图。字典相当于映射关系，通过键值对进行读取。适用于图只有少量的点，数据过多使用python类更为合适
graph = {
    "A": ["B", "C"],
    "B": ["A", "C", "D"],
    "C": ["A", "B", "D", "E"],
    "D": ["B", "C", "E", "F"],
    "E": ["C", "D"],
    "F": ["D"]
}

# 开始DFS遍历
# graph是图数据，s是图的起点
def BFS(graph, s):
    # 创建一个数组作为栈，用于存储未访问过的点
    stack = []
    # 放入起点
    stack.append(s)
    # 创建一个集合，用于存放已读入的点，例如起点s
    seen = set()
    seen.add(s)
    # 循环读stack
    while (len(stack) > 0):
        # 通过queue.pop()读取栈最后一个
        vertex = stack.pop()
        # 读取每个点相邻的点
        nodes = graph[vertex]
        # 判重：循环判断相邻的点是否读过
        for w in nodes:
            if w not in seen:
                stack.append(w)
                seen.add(w)
        # 输出遍历节点
        print(vertex, end= ' ')

BFS(graph, "A")
'''
# 运行结果
A C E D F B 
'''

python实现DFS树

在这里插入图片描述

# 创建树节点类val：值，left：左子树，right：右子树
class TreeNode:
    def __init__(self, value):
        self.val = value
        self.left = None
        self.right = None


# 深搜遍历二叉树
def DFS(root):
    # 创建存放结果数组
    res = []
    # 创建栈，栈具有后进先出的特性，首先放入根节点
    stack = [root]
    # 循环栈
    while stack:
        # 取出栈最后一个元素
        currentNode = stack.pop()
        # 田间取出元素的值
        res.append(currentNode.val)
        # 是否含右子树
        if currentNode.right:
            # 添加右子树到栈
            stack.append(currentNode.right)
        # 是否含左子树
        if currentNode.left:
            # 添加左子树到栈
            stack.append(currentNode.left)

    # 返回结果
    return res


if __name__ == "__main__":
    tree = TreeNode(4)  # 添加根节点
    tree.left = TreeNode(9)  # 添加根左子树
    tree.right = TreeNode(0)  # 添加根右子树，以下以此类推
    tree.left.left = TreeNode(5)
    tree.left.right = TreeNode(1)
    tree.right.left = TreeNode(3)
    tree.right.right = TreeNode(2)
    tree.left.left.left = TreeNode(10)
    tree.right.left.right = TreeNode(7)

    print(DFS(tree))
    # [4, 9, 5, 10, 1, 0, 3, 7, 2]
'''
运行结果：
[4, 9, 5, 10, 1, 0, 3, 7, 2]
'''

何时使用深搜和广搜

  1. BFS是用来搜索最短径路的解是比较合适的，比如求最少步数的解，最少交换次数的解，因为BFS搜索过程中遇到的解一定是离根最近的，所以遇到一个解，一定就是最优解，此时搜索算法可以终止。这个时候不适宜使用DFS，因为DFS搜索到的解不一定是离根最近的，只有全局搜索完毕，才能从所有解中找出离根的最近的解。（当然这个DFS的不足，可以使用迭代加深搜索ID-DFS去弥补）。
  2. 空间优劣上，DFS是有优势的，DFS不需要保存搜索过程中的状态，而BFS在搜索过程中需要保存搜索过的状态，而且一般情况需要一个队列来记录。
  3. DFS适合搜索全部的解，因为要搜索全部的解，那么BFS搜索过程中，遇到离根最近的解，并没有什么用，也必须遍历完整棵搜索树，DFS搜索也会搜索全部，但是相比DFS不用记录过多信息，所以搜素全部解的问题，DFS显然更加合适。

python实现树前中后序遍历

在这里插入图片描述

前序遍历

# 定义一个树的节点
class TreeNode:
    def __init__(self, x):
        self.val = x  # 值
        self.left = None  # 左节点
        self.right = None  # 右节点


# 前序遍历，lis是传入的list型参数，为了递归得到一个遍历List结果
def preorder(root, result):
    result.append(root.val)  # 添加根节点值
    if root.left:
        preorder(root.left, result)  # 递归寻找左子树
    if root.right:
        preorder(root.right, result)  # 递归寻找右子树
    return result


if __name__ == "__main__":
    tree = TreeNode(4)  # 添加根节点
    tree.left = TreeNode(9)  # 添加根左子树
    tree.right = TreeNode(0)  # 添加根右子树，以下以此类推
    tree.left.left = TreeNode(5)
    tree.left.right = TreeNode(1)
    tree.right.left = TreeNode(3)
    tree.right.right = TreeNode(2)
    tree.left.left.left = TreeNode(10)
    tree.right.left.right = TreeNode(7)

    print(preorder(tree, []))
    # [4, 9, 5, 10, 1, 0, 3, 7, 2]

中序遍历

# 定义一个树的节点
class TreeNode:
    def __init__(self, x):
        self.val = x  # 值
        self.left = None  # 左节点
        self.right = None  # 右节点


# 中序遍历，lis是传入的list型参数，为了递归得到一个遍历List结果
def infix_order(root, result):
    if root.left:
        infix_order(root.left, result)
    result.append(root.val)
    if root.right:
        infix_order(root.right, result)
    return result


if __name__ == "__main__":
    tree = TreeNode(4)  # 添加根节点
    tree.left = TreeNode(9)  # 添加根左子树
    tree.right = TreeNode(0)  # 添加根右子树，以下以此类推
    tree.left.left = TreeNode(5)
    tree.left.right = TreeNode(1)
    tree.right.left = TreeNode(3)
    tree.right.right = TreeNode(2)
    tree.left.left.left = TreeNode(10)
    tree.right.left.right = TreeNode(7)

    print(infix_order(tree, []))
    # [10, 5, 9, 1, 4, 3, 7, 0, 2]

后序遍历

# 定义一个树的节点
class TreeNode:
    def __init__(self, x):
        self.val = x  # 值
        self.left = None  # 左节点
        self.right = None  # 右节点


# 后序遍历，result是传入的list型参数，为了递归得到一个遍历List结果
def epilogue(root, result):
    if root.left:
        epilogue(root.left, result)
    if root.right:
        epilogue(root.right, result)
    result.append(root.val)
    return result


if __name__ == "__main__":
    tree = TreeNode(4)  # 添加根节点
    tree.left = TreeNode(9)  # 添加根左子树
    tree.right = TreeNode(0)  # 添加根右子树，以下以此类推
    tree.left.left = TreeNode(5)
    tree.left.right = TreeNode(1)
    tree.right.left = TreeNode(3)
    tree.right.right = TreeNode(2)
    tree.left.left.left = TreeNode(10)
    tree.right.left.right = TreeNode(7)

    print(epilogue(tree, []))
    # [10, 5, 1, 9, 7, 3, 2, 0, 4]

参考资料

AI AX AT
关注
  • 17
    点赞
  • 踩
  • 98
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于python模拟bfs和dfs代码实例
01-19
# 广搜 def bfs(graph, start): queue = [start] # 先把起点入队列 visited = set() # 访问国的点加入 visited.add(start) while len(queue): vertex = queue.pop(0) # 找到队列首元素的连接点 for v in ...
二叉树遍历BFS与DFS详细代码python版
01-18
二叉树遍历BFS与DFS详细代码python版
【Python搜索算法】广度优先搜索（BFS）算法原理详解与应用，示例+代码
qq_35831906的博客
10-16 6956
广度优先搜索（Breadth-First Search，BFS）是一种图遍历算法，用于系统地遍历或搜索图（或树）中的所有节点。BFS的核心思想是从起始节点开始，首先访问其所有相邻节点，然后逐层向外扩展，逐一访问相邻节点的相邻节点，以此类推。这意味着BFS会优先探索距离起始节点最近的节点，然后再逐渐扩展到距离更远的节点。BFS通常用于查找最短路径、解决迷宫问题、检测图是否连通以及广泛的图问题。BFS算法的步骤如下：初始化：选择一个起始节点，将其标记为已访问，并将其放入队列中（作为起始节点）。
BFS算法 （python)
cindera的刷题记录
03-06 7973
广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。 也就是我们在数据结构中学习过的BFS算法。按层数的遍历。 同上图所示，我们从A开始得到它的一个BFS就是ABCDEF。我们使用代码实现该程序。 grap = { "A":["B","C"], "B":["A","C","D"], "C":["A","B","D","E"], "D":["B","C".
PYTHON实现图的深度优先搜索(DFS)和广度优先搜索(BFS)算法
book_dw5189的博客
05-02 1282
深度优先遍历在图中一般使用栈来实现。广度优先遍历一般使用队列来实现。
Python BFS和DFS算法
qq_43540763的博客
03-23 8231
Python BFS和DFS算法 看了b站灯神的视频，整理如下。最后再加上几条实战题。 1.BFS bfs全称是广度优先搜索，任选一个点作为起始点，然后选择和其直接相连的（按顺序展开）走下去。主要用队列实现，直接上图。两个搜索算法都只需要把图全都遍历下来就好。 具体实现时：用字典来表示图；队列直接用python里的列表就好 python代码： graph={ "A":["B","C"], "B":["A","C","D"], "C":["A","B","D","E"], "
算法试题（Python实现）dfs、矩阵路径
Zincy星辰
02-05 886
1.分糖果问题（贪心思想） 2.主持人调度（二）（贪心思想） 3.N皇后问题（递归） 4.岛屿数量（dfs） 5.设计LRU缓存结构（哈希表+双向链表） 6.设计LFU缓存结构（双哈希表） 7.​​​​​​​螺旋矩阵（边界模拟法） 8.顺时针旋转矩阵（倒置翻转法） 9.不同路径的数目(一) 10.矩阵最长递增路径（dfs+DP） 11.矩阵的最小路径和 12.编辑距离(一) 13.​​​​​​​旋转数组（平移数组：三次翻转法）
python实现DFS和BFS整理
January001的博客
11-25 1110
BFS是广度遍历，也就是一层一层扩展开的查找，先把第一层的找完，再找第二层，然后找第三层...使用到的数据结构是队列，先访问第一个节点，然后访问它的所有邻接点，然后访问邻接点的邻接点，在此过程中，要保证访问过的点不重复访问。 DFS是深度遍历，从一个点开始，逐渐沿着一条路径向下查找，查找到尽头的时候，回溯到上一个节点，再继续查找...使用的数据结构是栈，访问的下一个节点是当前节点的一个邻接点，然...
搜索入门——BFS和DFS
12-18
从最基础的迷宫问题看深搜和宽搜的内涵，理解最基础的穷举搜索。
Python实现机器人路径规划实验(A*、BFS、DFS、D*四种路径搜索算法)
05-27
在Python实现这四种算法时，通常会用到数据结构如队列（用于BFS）和栈（用于DFS），以及优先级队列（用于A*和D*）。同时，还需要表示地图的二维数组或图数据结构，以及启发式函数（如曼哈顿距离或欧几里得距离）。 ...
MFC树控件BFS和DFS示例
09-24
在本文中，我们将深入探讨如何在MFC（Microsoft Foundation Class）框架中利用CTreeCtrl类实现树形控件的遍历，特别是在标题“MFC树控件BFS和DFS示例”中提到的广度优先搜索（BFS）和深度优先搜索（DFS）。...
python的BFS，DFS，UCS，A星算法
09-29
python的搜索算法，例如深度优先算法，A星算法，其中的h函数可以优化，原文件只采用了欧氏距离。
python实现图的深度优先遍历(DFS)和广度优先遍历(BFS)算法
qq_38773993的博客
08-08 6873
#图的深度优先和广度优先遍历 def DFS(graph,s): #深度优先遍历,基于栈 stack=[] #建立栈 stack.append(s) data=[] #记录已经遍历过的点 data.append(s) while stack: n=stack.pop() # 取出栈中最后一个元素并删掉 nodes=graph[n] for i in nodes[::-1]: #栈先进后出 i.
Python算法——深度优先搜索(DFS)
Echo_Wish的博客
11-11 728
这表示从节点’A’出发，按深度优先的顺序访问了图中的所有节点。在实际应用中，深度优先搜索常用于解决与图或树相关的问题，如查找路径、拓扑排序、连通性检测等。深度优先搜索的核心思想是通过递归或使用栈来遍历图或树的节点。
Python——数据结构——图——图的遍历——DFS与BFS
qq_41188247的博客
01-07 838
Python——数据结构——图——图的遍历——DFS与BFS
关于DFS和BFS算法——Python的代码实现和讲解。
Kinght_123的博客
01-13 7734
1.什么是DFS和BFS？ DFS DFS，通俗来讲，就是深度优先搜索，它可以通过栈来实现。 举个例子： 图中的例子以A为出发点。 那么DFS的其中一个结果就是ABDFEC。 简单点概括就是一条路走到黑，如果无路可走了，就会有一个回溯的过程，直到所有的节点都已经走过了。 BFS BFS，通俗来讲，就是广度优先搜索，它可以通过队列来实现。 也是上面的图片的例子： BFS的其中一个结果就是：ABCDEF， 概括来说，就是把每个的相关点都依次的写出来。 2.DFS和BFS的代码实现 DFS的代码实现
Python：跳蚱蜢（BFS判重）
qq_65144447的博客
02-17 553
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列， 并且保持空盘的位置不变（也就是 1−8 换位，2−7换位,...），至少要经过多少次跳跃？如下图所示： 有 9 只盘子，排成 1 个圆圈。其中 8 只盘子内装着 8 只蚱蜢，有一个是空盘。我们把这些蚱蜢顺时针编号为 1 ~ 8。每只蚱蜢都可以跳到相邻的空盘中， 也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
关于python DFS的思考
Mr_king138的博客
03-31 160
dfs
Python深搜讲解
最新发布
06-13
Python中的深度优先搜索（Depth-First Search，DFS）是一种用于遍历或搜索树或图数据结构的算法策略。在深度优先搜索中，我们从起始节点开始，尽可能深地沿着分支探索，直到到达某个叶子节点（没有未访问的孩子节点），然后回溯到上一个节点并继续下一个分支，直到所有可达节点都被访问过。 以下是深度优先搜索的基本步骤： 1. **选择一个起始节点**：通常是从根节点开始，如果没有根节点，则选择任意一个未访问的节点。 2. **标记当前节点为已访问**：将其添加到已访问集合中，避免重复访问。 3. **递归遍历子节点**：对于当前节点的所有未访问子节点，递归调用DFS函数。 4. **如果找到目标节点**：返回结果。 5. **如果当前节点无子节点或所有子节点都已访问**：结束当前路径，回溯到上一个节点。 深度优先搜索可以用递归实现（如`stack`数据结构），也可以使用堆栈辅助（模拟递归过程）。常见的应用包括迷宫问题、拓扑排序、遍历文件系统等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值