广度/深度优先搜索算法 - python实现

1. 图

定义:图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成,通常表示为:G(V,E),其中,G表示一个图,V是图G中顶点的集合,E是图G中边的集合.

简单点的说:图由节点和边组成。一个节点可能与众多节点直接相连,这些节点被称为邻居。

如二叉树就为一个简单的图:

更加详细的信息可参见:https://www.cnblogs.com/polly333/p/4760275.html

2. 算法

1). 广度优先搜索:

广度优先搜索算法(Breadth First Search,BSF),思想是:

  • 1.从图中某顶点v出发,首先访问定点v
  • 2.在访问了v之后依次访问v的各个未曾访问过的邻接点;
  • 3.然后分别从这些邻接点出发依次访问它们的邻接点,并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问;
  • 4.直至图中所有已被访问的顶点的邻接点都被访问到;
  • 5.如果此时图中尚有顶点未被访问,则需要另选一个未曾被访问过的顶点作为新的起始点,重复上述过程,直至图中所有顶点都被访问到为止。

换句话说,广度优先搜索遍历图的过程是以v为起点,由近至远,依次访问和v有路径相通且路 径长度为1,2...的顶点。

如上图的BFS访问顺序为:

A->B->C->D->E->F

2). 深度优先搜索:

图的深度优先搜索(Depth First Search, DFS),和树的前序遍历非常类似。

它的思想:

  • 1.从顶点v出发,首先访问该顶点;
  • 2.然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图;
  • 3.直至图中所有和v有路径相通的顶点都被访问到。
  • 4.若此时尚有其他顶点未被访问到,则另选一个未被访问的顶点作起始点,重复上述过程,直至图中所有顶点都被访问到为止

如上图的BFS访问顺序为:

A->B->D->E->C->F

3. 代码

# -*- coding: utf-8 -*-
#/usr/bin/python

from collections import deque
import sys

class Graph(object):
    def __init__(self, *args, **kwargs):
        self.order = []     #visited order
        self.neighbor = {}

    def add_node(self, node):
        key,val = node
        if not isinstance(val, list):
            print(‘node value should be a list‘)
            #sys.exit(‘failed for wrong input‘)

        self.neighbor[key] = val

    def broadth_first(self, root):
        if root != None:
            search_queue = deque()
            search_queue.append(root)

            visited = []
        else:
            print(‘root is None‘)
            return -1

        while search_queue:
            person = search_queue.popleft()
            self.order.append(person)

            if (not person in visited) and (person in self.neighbor.keys()):
                search_queue += self.neighbor[person]
                visited.append(person)

    def depth_first(self, root):
        if root != None:
            search_queue = deque()
            search_queue.append(root)

            visited = []
        else:
            print(‘root is None‘)
            return -1

        while search_queue:
            person = search_queue.popleft()
            self.order.append(person)

            if (not person in visited) and (person in self.neighbor.keys()):
                tmp = self.neighbor[person]
                tmp.reverse()

                for index in tmp:
                    search_queue.appendleft(index)

                visited.append(person)
                #self.order.append(person)

    def clear(self):
        self.order = []

    def node_print(self):
        for index in self.order:
            print(index, end=‘  ‘) 

if __name__ == ‘__main__‘:
    g = Graph()
    g.add_node((‘1‘,[‘one‘, ‘two‘,‘three‘]))
    g.add_node((‘one‘,[‘first‘,‘second‘,‘third‘]))
    g.add_node((‘two‘,[‘1‘,‘2‘,‘3‘]))

    g.broadth_first(‘1‘)

    print(‘broadth search first:‘)
    print(‘  ‘, end=‘  ‘)
    g.node_print()

    g.clear()

    print(‘\n\ndepth search first:‘)
    print(‘  ‘, end=‘  ‘)
    g.depth_first(‘1‘)

    g.node_print()
    print()

ps: 以上代码需要用python3.x运行,python2.x不支持print的关键字参数

PS2: 以上代码有些许不完善,如果你有改进的方法,请留言,万分感谢!

原文地址:https://www.cnblogs.com/Jimmy1988/p/8184192.html

时间: 2024-11-05 18:34:22

广度/深度优先搜索算法 - python实现的相关文章

图的深度优先搜索算法DFS

1.问题描述与理解 深度优先搜索(Depth First Search,DFS)所遵循的策略,如同其名称所云,是在图中尽可能"更深"地进行搜索.在深度优先搜索中,对最新发现的顶点v若此顶点尚有未探索过从其出发的边就探索之.当v的所有边都被探索过,搜索"回溯"到从其出发发现顶点v的顶点.此过程继续直至发现所有从源点可达的顶点.若图中还有未发现的顶点,则以其中之一为新的源点重复搜索,直至所有的顶点都被发现.与BFS中源顶点是指定的稍有不同. DFS搜索轨迹Gπ将形成一片

深度优先搜索算法(DFS)以及leetCode的subsets II

深度优先搜索算法(depth first search),是一个典型的图论算法.所遵循的搜索策略是尽可能“深”地去搜索一个图. 算法思想是: 对于新发现的顶点v,如果它有以点v为起点的未探测的边,则沿此边继续探测下去.当顶点v的所有边都已被探寻结束,则回溯到到达点v的先辈节点.以相同方法一直回溯到源节点为止.如果图中还有未被发现的顶点,则选择其中一个作为源顶点,重复以上的过程.最后的结果是一些不相交的深度优先树. leetCode中的应用: Given a collection of integ

深度优先搜索算法

一.深度优先搜索 深度优先搜索算法(Depth First Search),是图论中的经典算法. 深度优先搜索算法是沿着树的深度遍历树的节点,尽可能深的搜索树的分支.当结点所有子结点那一层都被搜索过,再回溯返回到当前结点的邻结点,继续搜索,直到遍历完整棵树.一般采用的是前序遍历,先根然后再左右结点的方式进行. 任何DFS只需要通过下面几步就可以实现,无论是递归还是非递归方式.我给这几步分别做了一个命名,分别是find.forward.done.back. 如下: 1.find(right):在树

深度优先搜索算法的概念

深度优先搜索算法的概念 与广度优先搜索算法不同,深度优先搜索算法类似与树的先序遍历.这种搜索算法所遵循的搜索策略是尽可能"深"地搜索一个图.它的基本思想如下:首先访问图中某一个起始顶点v,然后由v出发,访问与v相邻且未被访问的任一顶点w1,再访问与w1邻接且未被访问的任一顶点w2,-.重复上述过程.当不能再继续向下访问时,依次退回到最近被访问的顶点,若它还有邻接顶点未被访问过,则从该点开始继续上述搜索过程,直到图中所有顶点均被访问过为止(还是举相同的例子,从你开始遍历你的所有亲戚,例如

广度优先、深度优先搜索算法——面试题

广度优先搜索(Breadth-first Search) BFS在求解最短路径或者最短步数上有很多的应用.应用最多的是在走迷宫上. 分析 树的定义本身就是一种递归定义,因此对于树相关的算法题,递归是最好的解决思路(在递归深度允许的情况下). 递归版 public class Solution { public boolean isSymmetric(TreeNode root) { return root==null||isMirror(root.left,root.right); } priv

和声搜索算法-python实现

HSIndividual.py 1 import numpy as np 2 import ObjFunction 3 4 5 class HSIndividual: 6 7 ''' 8 individual of harmony search algorithm 9 ''' 10 11 def __init__(self, vardim, bound): 12 ''' 13 vardim: dimension of variables 14 bound: boundaries of varia

DFS --- Depth First Search 深度优先搜索算法

Depth First Search 原理还是去看<DSAA>,这里着重分析实现策略. 如果对于图这种数据结构不熟悉,这个BFS一般是搞不定的... 下面分别是无向图的邻接表实现和邻接矩阵实现 http://blog.csdn.net/cinmyheart/article/details/41381845 http://blog.csdn.net/cinmyheart/article/details/41370465 --------------------------------------

广度优先和深度优先搜索算法

#include <iostream> #include <stdlib.h> #include <vector> #include <string> #include <queue> #include <stack> using namespace std; //邻接矩阵显示图 void show_graph(vector<vector<int>> &graph) { for (int i = 0;

BFS/DFS 广度/深度优先搜索

深度优先搜索DFS 所谓深度优先搜索,通俗点理解就是一条路走到头--不撞南墙不回头. 我们先来看一个全排列问题,现在要对1 2 3进行全排列,现在小哼手上拿着1 2 3三张卡片,他要将这三张卡片放入三个盒子里,每放满不就是一种全排列了么? 但是每次到底是先放卡片1还是卡片2,3呢? 小哼想,我按顺序放吧,每次都按照1.2.3的顺序放卡片.于是他走到1号盒子前把卡片1放入,走到2号盒子前把卡片2放入,走到3号盒子前把卡片3放入,走到四号盒子...但小哼的卡片已经放完 啦.这时就产生了一种全排列"1