图的遍历——DFS与BFS_bfs dfs图遍历-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_28053699/article/details/89002206

本文探讨了图的遍历方法，包括无向图的邻接矩阵存储结构，详细介绍了深度优先遍历（DFS）和广度优先遍历（BFS）的原理，并给出了相应的代码实现及测试数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

图的遍历

图的遍历 $(Traversing\ Grapb )$ ：从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫做图的遍历。

无向图的邻接矩阵储存结构代码

class Undirected_Graph_Matrix(object):
#Adjacency Matrix
    def __init__(self, vertices=[], edges_list=[]):                 
        self.edges_dict = {}                                        #{(tail, head):weight}
        self.edges_list=edges_list                                  #(tail, head, weight)
        self.vertices = vertices                                    #顶点
        self.num_edges = len(self.edges_list)                       #边的数目
        self.num_vertices = len(self.vertices)                      #顶点数目
        self.Mat = zeros((self.num_vertices,self.num_vertices))     #邻接矩阵
        
        if len(self.vertices) == 0:
        #图不能为空
            print('图不能为空')
            raise IndexError

        for Edge in edges_list:
        #根据edges_list生成self.edges_dict
            self.edges_dict[(Edge[0],Edge[1])]=Edge[2]
        
        for i in range(self.num_vertices):
            for j in range(self.num_vertices):
                if i==j:
                    self.Mat[i][j]=0
                elif (vertices[i],vertices[j]) in self.edges_dict:
                    self.Mat[i][j]=self.edges_dict[(vertices[i],vertices[j])]
                    self.Mat[j][i]=self.edges_dict[(vertices[i],vertices[j])]
                elif (vertices[j],vertices[i]) in self.edges_dict:
                    self.Mat[i][j]=self.edges_dict[(vertices[j],vertices[i])]
                    self.Mat[j][j]=self.edges_dict[(vertices[j],vertices[i])]
                else:
                    self.Mat[i][j]=inf
                    self.Mat[j][i]=inf

深度优先遍历

深度优先遍历 $Depth\_First\_Search)$ ，也有称为深度优先搜索，简称为 $D F S$ ，它从图中某个顶点 $v$ 出发，访问此顶点，然后从 $v$ 的未被访问的邻接点出发深度优先遍历图，直至图中所有和 $v$ 有路径相通的顶点都被访问到。

深度优先遍历代码

def DFS(G,i,Visited):
    Visited[i]=1
    print(G.vertices[i])
    for j in range(G.num_vertices):
        if 0<=G.Mat[i][j]<inf and Visited[j]==0 and i!=j:
            DFS(G,j,Visited)
            
def DFSTraverse(G):
    Visited=[0 for i in range(G.num_vertices)]
    for i in range(G.num_vertices):
        if Visited[i]==0:DFS(G,i,Visited)

广度优先遍历

广度优先遍历 $Breadth\_First\_ Search)$ ，又称为广度优先搜索，简称 $B F S$ ，它从图中某个顶点 $v$ 出发，访问此顶点，接着对 $v$ 的所有邻接点进行访问，然后再对每个访问的顶点进行如 $v$ 般操作。

广度优先遍历代码

def BFS(G,List,Visited):    
    Q=[]
    for i in List:
        print(G.vertices[i])
        for j in range(i):
            if 0<=G.Mat[i][j]<inf and Visited[j]==0 and i!=j:
                Q.append(j)
                Visited[j]=1
    if Q:BFS(G,Q,Visited)

def BFSTraverse(G):
    Visited=[0 for i in range(G.num_vertices)]
    for i in range(G.num_vertices):
        if Visited[i]==0:
            Visited[i]=1
            BFS(G,[i],Visited)

DFS与BFS的完整代码以及测试数据

# -*- coding: utf-8 -*-
"""
Created on Thu Mar 21 22:04:14 2019

@author: Administrator
"""
from numpy import *

class Undirected_Graph_Matrix(object):
#Adjacency Matrix
    def __init__(self, vertices=[], edges_list=[]):                 
        self.edges_dict = {}                                        #{(tail, head):weight}
        self.edges_list=edges_list                                  #(tail, head, weight)
        self.vertices = vertices                                    #顶点
        self.num_edges = len(self.edges_list)                       #边的数目
        self.num_vertices = len(self.vertices)                      #顶点数目
        self.Mat = zeros((self.num_vertices,self.num_vertices))     #邻接矩阵
        
        if len(self.vertices) == 0:
        #图不能为空
            print('图不能为空')
            raise IndexError

        for Edge in edges_list:
        #根据edges_list生成self.edges_dict
            self.edges_dict[(Edge[0],Edge[1])]=Edge[2]
        
        for i in range(self.num_vertices):
            for j in range(self.num_vertices):
                if i==j:
                    self.Mat[i][j]=0
                elif (vertices[i],vertices[j]) in self.edges_dict:
                    self.Mat[i][j]=self.edges_dict[(vertices[i],vertices[j])]
                    self.Mat[j][i]=self.edges_dict[(vertices[i],vertices[j])]
                elif (vertices[j],vertices[i]) in self.edges_dict:
                    self.Mat[i][j]=self.edges_dict[(vertices[j],vertices[i])]
                    self.Mat[j][j]=self.edges_dict[(vertices[j],vertices[i])]
                else:
                    self.Mat[i][j]=inf
                    self.Mat[j][i]=inf


    

def DFS(G,i,Visited):
    Visited[i]=1
    print(G.vertices[i])
    for j in range(G.num_vertices):
        if 0<=G.Mat[i][j]<inf and Visited[j]==0 and i!=j:
            DFS(G,j,Visited)
            
def DFSTraverse(G):
    Visited=[0 for i in range(G.num_vertices)]
    for i in range(G.num_vertices):
        if Visited[i]==0:DFS(G,i,Visited)
    

    
def BFS(G,List,Visited):    
    Q=[]
    for i in List:
        print(G.vertices[i])
        for j in range(i):
            if 0<=G.Mat[i][j]<inf and Visited[j]==0 and i!=j:
                Q.append(j)
                Visited[j]=1
    if Q:BFS(G,Q,Visited)

def BFSTraverse(G):
    Visited=[0 for i in range(G.num_vertices)]
    for i in range(G.num_vertices):
        if Visited[i]==0:
            Visited[i]=1
            BFS(G,[i],Visited)
    
    
vertices=['A','B','C','D','E','F','G','H','I']
edges_list=[['C','I',8],['A','B',10],['A','F',11],['B','C',18],['B','I',12],['B','G',16],['F','G',17],['F','E',26],['C','D',22],['I','D',21],['G','D',24],['G','H',19],['E','H',7],['H','D',16]]
G=Undirected_Graph_Matrix(vertices,edges_list)   
DFSTraverse(G)
print('.........................') 
BFSTraverse(G)