Python —— BFS 和 DFS

Python —— BFS 和 DFS

BFS遍历（运用队列）：

graph = {
    "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) # s为起始点
    seen = 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)


BFS(graph, "E")

运行结果：

DFS遍历（运用栈）

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


def DFS(graph, s):
    stack = []
    stack.append(s) # s为起始点
    seen = 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)

DFS(graph, "E")

运行结果：

应用

1. BFS用来求起始点到其他各个点的最短路径，先来看边不带权的如图：
   通过回溯父结点来寻找最短路径

graph = {
    "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) # s为起始点
    seen = set() #存储已经遍历过的点
    seen.add(s)
    parent = {s:None} #起始点的父节点为空
    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)
                parent[w] = vertex #设父结点
    return parent

parent = BFS(graph , "E") # E为起始点
v = "B" #目标结点
ans = [] #起点到终点的最短路径
while v != None:
    ans.append(v)
    v = parent[v]
ans = ans[::-1]
print (ans)

运行结果：

2. Dilkstra算法求带权图的起始点到各个点的最短路径，如图：

import heapq
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] = 0x3f3f3f
    return distance

def dilkstra(graph, s):
    pqueue = []
    heapq.heappush(pqueue,(0,s)) # s为起始点
    seen = set() #存储已经遍历过的点
    parent = {s:None} #起始点的父节点为空
    distance = init_distance(graph,s)

    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 = dilkstra(graph,"A")
print("Parent：",end='')
print(parent)
print("Distance：",end='')
print(distance)

运行结果：