图的基本方法（BFS 和DFS 的 遍历）

图的形式如下所示：

分别使用 BFS DFS 来对图进行遍历；并利用BFS 来求  无权重图的无向图 的最短路径

#!/usr/bin/python
# -*- coding: UTF-8 -*-
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,start):
    queue = []
    visted = set()
    queue.append(start)
    visted.add(start)
    layer = []
    while(len(queue) >0):
        node = queue.pop(0)
        neighbors = graph[node]
        for v in neighbors:
            if v not in visted:
                queue.append(v)
                visted.add(v)
        layer.append(node)
    return layer
layer = BFS(graph,'A')
print(layer)

def BFS_withLayer(graph,start):
    queue = []
    visted = set()
    queue.append(start)
    visted.add(start)
    layers = []
    while(len(queue) >0):
        len_queue = len(queue)
        layer =  []
        for i in range(len_queue):
            node = queue.pop(0)
            layer.append(node)
            visted.add(start)
            neighbors = graph[node]
            for v in neighbors:
                if v not in visted:
                    queue.append(v)
                    visted.add(v)
        layers.append(layer)
    return layers
layers = BFS_withLayer(graph,'A')
print(layers)
print('----------------------------------')

def DFS(graph,start):
    stack = []
    visted = set()
    stack.append(start)
    visted.add(start)
    layer = []
    while(len(stack) >0):
        node = stack.pop()
        neighbors = graph[node]
        for v in neighbors:
            if v not in visted:
                stack.append(v)
                visted.add(v)
        layer.append(node)
    return layer
layer = DFS(graph,'A')
print(layer)

print("=============================")
### 利用BFS来求无权值的无向图的最短路径问题：
def BFS_Short_Path(graph,start):
    queue = []
    visted = set()
    parent = {}
    queue.append(start)
    visted.add(start)
    parent[start] = None
    while(len(queue) >0):
        node =queue.pop(0)
        neighbors = graph[node]
        for v in neighbors:
            if v not in visted:
                queue.append(v)
                visted.add(v)
                parent[v] = node
        # print(node)
    return parent
parents = BFS_Short_Path(graph,'A')
print(parents)
## 则从 A 到E的路径为
v = 'E'
path = []
path.append(v)
while parents[v] != None:
    path.append(parents[v])
    v = parents[v]
print(path)
print(path[::-1])

输出的结果为：

['A', 'B', 'C', 'D', 'E', 'F']
[['A'], ['B', 'C'], ['D', 'E'], ['F']]
----------------------------------
['A', 'C', 'E', 'D', 'F', 'B']
=============================
{'A': None, 'E': 'C', 'C': 'A', 'B': 'A', 'D': 'B', 'F': 'D'}
['E', 'C', 'A']
['A', 'C', 'E']

若图是如下所示，应如何实现：

具体的代码如下 ：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import heapq
import math
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_distnce(graph,start):
    distance ={}
    for v in graph.keys():
        if v !=start:
            distance[v] = 999999
        else:
            distance[v] = 0
    return distance
# t = init_distnce(graph,'A')
# print(t)
def dijkstra(graph,start):
    pqueue = []
    heapq.heappush(pqueue,(0,start))
    visted = set()
    distance = init_distnce(graph,start)
    parent = {start:None}
    while(len(pqueue)>0):
        pair = heapq.heappop(pqueue)
        dist = pair[0]
        node = pair[1]
        visted.add(node)
        neighbors = graph[node].keys()
        for w in neighbors:
            if w not in visted:
                if dist + graph[node][w] < distance[w]:
                    heapq.heappush(pqueue,(dist + graph[node][w],w))
                    parent[w] = node
                    distance[w] = dist + graph[node][w]
    return distance,parent

distance,parent = dijkstra(graph,'A')
print("Parent: ",parent)
print("Distance: ",distance)

结果：

Parent:  {'F': 'D', 'C': 'A', 'E': 'D', 'D': 'B', 'A': None, 'B': 'C'}
Distance:  {'F': 10, 'C': 1, 'E': 7, 'D': 4, 'A': 0, 'B': 3}