Python算法-深度优先搜索&广度优先搜索（DFS&BFS）

Posted 2023-04-04

参考技术A

大树满足条件的和 等于 每个子树满足条件的数的和之和

result = 0 + 10 + 15 + 18

深度优先搜索必然会使用到 递归

必须使用到辅助队列，用于判断

找到共同的祖先

对相同像素的相邻位置进行渲染

给定一个包含了一些 0 和 1 的非空二维数组 grid 。
一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

Scrapy实战2：爬虫深度&&广度优先算法

一、前言

以后尽量每天更新一篇，也是自己的一个学习打卡！加油！今天给大家分享的是，Python里深度/广度优先算法介绍及实现。

二、深度、广度优先算法简介

1.深度优先搜索(DepthFirstSearch)

深度优先搜索的主要特征就是，假设一个顶点有不少相邻顶点，当我们搜索到该顶点，我们对于它的相邻顶点并不是现在就对所有都进行搜索，而是对一个顶点继续往后搜索，直到某个顶点，他周围的相邻顶点都已经被访问过了，这时他就可以返回，对它来的那个顶点的其余顶点进行搜索。
深度优先搜索的实现可以利用递归很简单地实现。

2.广度优先搜索(BreadthFirstSearch)

广度优先搜索相对于深度优先搜索侧重点不一样，深度优先好比是一个人走迷宫，一次只能选定一条路走下去，而广度优先搜索好比是一次能够有任意多个人，一次就走到和一个顶点相连的所有未访问过的顶点，然后再从这些顶点出发，继续这个过程。

具体实现的时候我们使用先进先出队列来实现这个过程：

1. 首先将起点加入队列，然后将其出队，把和起点相连的顶点加入队列，

2. 将队首元素v出队并标记他

3. 将和v相连的未标记的元素加入队列，然后继续执行步骤2直到队列为空

广度优先搜索的一个重要作用就是它能够找出最短路径，这个很好理解，因为广度优先搜索相当于每次从一个起点开始向所有可能的方向走一步，那么第一次到达目的地的这个路径一定是最短的，而到达了之后由于这个点已经被访问过而不会再被访问，这个路径就不会被更改了。

三、看代码，边学边敲边记深度优先、广度优先算法

1.遍历二叉树图形

遍历二叉树图形

2.深度优先、广度优先遍历模型

 1'''
 2date : 2018.7.29
 3author : 极简XksA
 4goal : 深度/广度优先算法
 5'''
 6
 7# 深度优先： 根左右 遍历
 8# 广度优先： 层次遍历，一层一层遍历
 9
10# 深度优先： 根左右 遍历 (递归实现)
11def depth_tree(tree_node):
12    if tree_node is not None:
13        print(tree_node._data)
14        if tree_node._left is not None:
15            return depth_tree(tree_node._left)  # 递归遍历
16        if tree_node._right is not None:
17            return depth_tree(tree_node._right)  # 递归遍历
18
19# 广度优先： 层次遍历，一层一层遍历(队列实现)
20def level_queue(root):
21    if root is None:
22        return
23    my_queue = []
24    node = root
25    my_queue.append(node)  # 根结点入队列
26    while my_queue:
27        node = my_queue.pop(0) # 出队列
28        print(node.elem)   # 访问结点
29        if node.lchild is not None:
30            my_queue.append(node.lchild)    # 入队列
31        if node.rchild is not None:
32            my_queue.append(node.rchild)    # 入队列

3.数据结构设计、遍历代码

方法一：列表法

 1# 树的数据结构设计
 2# 1.列表法
 3# 简述：列表里包含三个元素：根结点、左结点、右结点
 4my_Tree = [
 5    'D', # 根结点
 6    ['B',
 7     ['F',[],[]],
 8     ['G',['E',[],[]],[]]
 9     ],  # 左子树
10    ['C',
11     [],
12     ['A',['H',[],[]],[]]
13     ]   # 右子树
14]
15
16# 列表操作函数
17# pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
18# insert() 函数用于将指定对象插入列表的指定位置,没有返回值。
19
20# 深度优先： 根左右 遍历 (递归实现)
21def depth_tree(tree_node):
22    if tree_node:
23        print(tree_node[0])
24        # 访问左子树
25        if tree_node[1]:
26            depth_tree(tree_node[1])  # 递归遍历
27        # 访问右子树
28        if tree_node[2]:
29            depth_tree(tree_node[2])  # 递归遍历        
30depth_tree(my_Tree)
31# result:
32#            D B F G E C A H
33
34# 广度优先： 层次遍历，一层一层遍历(队列实现)
35def level_queue(root):
36    if not root:
37        return
38    my_queue = []
39    node = root
40    my_queue.append(node)  # 根结点入队列
41    while my_queue:
42        node = my_queue.pop(0) # 出队列
43        print(node[0])   # 访问结点
44        if node[1]:
45            my_queue.append(node[1])    # 入队列
46        if node[2]:
47            my_queue.append(node[2])    # 入队列       
48level_queue(my_Tree)
49# result :
50#           D B C F G A E H

方法二：构造类节点法

 1#2.构造类
 2# Tree类，类变量root 为根结点，为str类型
 3# 类变量right/left 为左右节点，为Tree型，默认为空
 4class Tree:
 5    root = ''
 6    right = None
 7    left = None
 8    # 初始化类
 9    def __init__(self,node):
10        self.root = node
11
12    def set_root(self,node):
13        self.root = node
14
15    def get_root(self):
16        return self.root
17
18# 初始化树
19# 设置所有根结点
20a = Tree('A')
21b = Tree('B')
22c = Tree('C')
23d = Tree('D')
24e = Tree('E')
25f = Tree('F')
26g = Tree('G')
27h = Tree('H')
28# 设置节点之间联系，生成树
29a.left = h
30b.left = f
31b.right = g
32c.right = a
33d.left = b
34d.right = c
35g.left = e
36
37# 深度优先： 根左右 遍历 (递归实现)
38def depth_tree(tree_node):
39    if tree_node is not None:
40        print(tree_node.root)
41        if tree_node.left is not None:
42            depth_tree(tree_node.left)  # 递归遍历
43        if tree_node.right is not None:
44            depth_tree(tree_node.right)  # 递归遍历
45depth_tree(d)  # 传入根节点
46# result:
47#            D B F G E C A H
48
49# 广度优先： 层次遍历，一层一层遍历(队列实现)
50def level_queue(root):
51    if root is None:
52        return
53    my_queue = []
54    node = root
55    my_queue.append(node)  # 根结点入队列
56    while my_queue:
57        node = my_queue.pop(0) # 出队列
58        print(node.root)   # 访问结点
59        if node.left is not None:
60            my_queue.append(node.left)    # 入队列
61        if node.right is not None:
62            my_queue.append(node.right)    # 入队列
63level_queue(d)
64# result :
65#           D B C F G A E H

四、后言

可能大家会好奇,深度优先算法、广度优先算法对爬虫有什么用，不用好奇，慢慢后面就会懂得了。提前透露：几乎所有网站都有首页、XXX、XXX、XXX…在每个分页下，又有很多分页，这样所有url之间的联系实际上就可以比喻成一棵树，当我们想要系统爬取时，为了不重复爬取，对这颗树的遍历就尤为重要了，这里说到的深度优先、广度优先为最常用的遍历算法。

【完】

如果你觉得文章还不错，请大家点赞分享下。你的肯定是我最大的鼓励和支持。

说句题外话，有不少人想加我微信，看我朋友圈的每日分享，我姑且放出来，但名额有限，先来先得。 我的朋友圈不止有技术分享，更有我的日常感悟，还有我个人商业思维观点 速速扫码添加！

加我微信，送你Python大礼包

推荐阅读

好好学习，天天在看