BFS与DFS

参考链接：https://www.bilibili.com/video/av25761720?from=search&seid=7501021383222448137

第一讲：

1、BFS:广度优先搜索

如果是树的话，就很简单：树的BFS就是层次遍历

 

找A做起始点

当以E作为起点，BFS就是：E C D A B F

 

2、DFS:深度优先搜索

以A为起点：A B D F E C

 

BFS可以通过队列来保证层的顺序：

DFS:使用栈

第二讲：

graphs={
       "A":["B","C"],
       "B":["A","C","D"],
       "C":["A","B","D","E"],
       "D":["B","C","E","F"],
       "E":["C","D"],
       "F":["D"] 
       }

def BFS(graph,s):
    queue=[]
    queue.append(s)
    seen=set()#哈希set
    seen.add(s)
    while(len(queue)>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)
        
def DFS(graph,s):
    stack=[]
    stack.append(s)
    seen=set()#哈希set
    seen.add(s)
    while(len(stack)>0):
        vertex=stack.pop()
        nodes=graph[vertex]
        for w in nodes:
            if  w not in seen :
                stack.append(w)
                seen.add(w)
        print(vertex)

BFS:找最短路径

graphs={
       "A":["B","C"],
       "B":["A","C","D"],
       "C":["A","B","D","E"],
       "D":["B","C","E","F"],
       "E":["C","D"],
       "F":["D"] 
       }

def BFS(graph,s):
    queue=[]
    queue.append(s)
    seen=set()#哈希set
    seen.add(s)
    parent={s:None}
    #parent[w]=v 表示w的前一个点是v
    while(len(queue)>0):
        vertex=queue.pop(0)
        
        nodes=graphs[vertex]
        
        for w in nodes:
            if  w not in seen :
                queue.append(w)
                seen.add(w)
                parent[w]=vertex
        print(vertex)
    return parent
parent=BFS(graphs,"E")
for key in parent:
    print(key,parent[key])

v="B"
while v !=None:
    print(v)
    v=parent[v]

第三讲：

 

BFS到Dijkstra算法

参考：https://docs.python.org/3.0/library/heapq.html

优先队列入队，需要带一个权限

 

优先队列：每一个点带一个数字：数字小的在前面

import heapq#最小堆
import math
pqueue=[]#
heapq.heappush(pqueue,(1,"A"))
heapq.heappush(pqueue,(7,"B"))
heapq.heappush(pqueue,(3,"C"))
heapq.heappush(pqueue,(6,"D"))
heapq.heappush(pqueue,(2,"E"))

#heapq.heappop(pqueue)
graph={
       "A":{"B":5,"C":1},
       "B":{"A":5,"C":2,"D":1},
       "C":{"A":1,"B":2,"D":4,"E":8},
       "D":{"B":1,"C":4,"E":3,"F":6},
       "E":{"C":8,"D":3},
       "F":{"D":6} 
       }

def init_distance(graph,s):
    distance={s:0}
    for vertex in graph:
        if vertex!=s:
            distance[vertex]=math.inf
    return distance
def dijkstra(graph,s):
    pqueue=[]
    heapq.heappush(pqueue,(0,s))    
    seen=set()#哈希set
    #
    parent={s:None}
    
    distance=init_distance(graph,s)#距离起点的距离
    #parent[w]=v 表示w的前一个点是v
    while(len(pqueue)>0):
        
        pair=heapq.heappop(pqueue)
        dist=pair[0]
        vertex=pair[1]
        seen.add(vertex)
        nodes=graph[vertex].keys()
        
        
        for w in nodes:
            if  w not in seen :
                if dist+graph[vertex][w]<distance[w]:
                    heapq.heappush(pqueue,(dist+graph[vertex][w],w))
                    parent[w]=vertex
                    distance[w]=dist+graph[vertex][w]
    return parent,distance
parent,distance=dijkstra(graph,"A")
print(parent)
print(distance)                            
v="D"
while v !=None:
    print(v)
    v=parent[v]     
#打出从A到D

Dijkstra算法的代码：