Breadth First Search or BFS for a Graph 广度优先搜索算法 & Depth First Search or BFS for a Graph 深度优先搜索算

from collections import defaultdict

class Graph:
    def __init__(self):
        self.graph = defaultdict(list)
    def addEdge(self,u,v):
        self.graph[u].append(v)
        #print(self.graph)

    def BFS(self,s):
        # mark all the vertices as not visited
        visited=[False]*(len(self.graph))
        #create a queue for BFS
        queue=[]
        #mark the source node as visited and enqueue it
        queue.append(s)
        visited[s]=True
        while queue:
            #Dequeue a vertex from queue and print it
            s=queue.pop(0)
            print(s,end=" ")
            #get all adjacent vertice of the dequeued vertex s.If a adjacent has not been visited, then
            #mark it visited and enqueue it
            for i in self.graph[s]:
                if visited[i]==False:
                    queue.append(i)
                    #print(queue)
                    visited[i]=True

    def DFScore(self,v,visited):
        #mark current node as visited and print it
        visited[v]=True
        print(v,end=" ")
        #recur for all the vertices adjacent to this vertex
        for i in self.graph[v]:
            if visited[i]==False:
                self.DFScore(i,visited)
    def DFS(self,v):
        visited = [False] * (len(self.graph))
        self.DFScore(v,visited)




#create a graph given in the above diagram

g=Graph()
g.addEdge(0,1)
g.addEdge(0,2)
g.addEdge(1,2)
g.addEdge(2,0)
g.addEdge(2,3)
g.addEdge(3,3)
print ("Following is Breadth First Traversal"
                  " (starting from vertex 2)")
g.BFS(2)
print("")
print("Following is DFS from (starting from vertex 2)")
g.DFS(2)

OUT：

Following is Breadth First Traversal (starting from vertex 2)
2 0 3 1 
Following is DFS from (starting from vertex 2)
2 0 1 3 

BFS vs DFS (each simplest version):

1. Property differences:

•  BFS can find shortest path; DFS cannot.
• DFS can find backward edge (cycle); BFS cannot 
• DFS can do topological sort (next slide); BFS cannot 

2. Performance differences:

•  If some solutions are close to root, BFS
•  If solutions are deep but frequent, DFS