Python基于链接表实现无向图最短路径搜索

g = [
    ['A0', [('B1', 3), ('D3', 5)]],
    ['B1', [('C2', 4)]],
    ['C2', [('D3', 6), ('E4', 1)]],
    ['D3', [('E4', 2)]],
    ['E4', [('B1', 7)]],
]

for node in g:
    print(node[0],end=' ') 

for node in g:
    print('-------------------')
    print(node[0], ":", end='')
    edges = node[1]
    for e in edges:
        v, w = e
        print(v, w, end=';')
    print()

g = {
    'A0':{'B1': 3, 'D3': 5},
    'B1': {'C2': 4},
    'C2': {'D3': 6, 'E4': 1},
    'D3': {'E4':2},
    'E4': {'B1': 7}
}

for node in g.keys():
    print(node,end=" ")

print("查询与 A0 项点有连接的其它顶点")
for k, v in g.get('A0').items():
    print((k, v), end=";")

class Vertex:
    def __init__(self, name, v_id=0):
        # 顶点的编号
        self.v_id = v_id
        # 顶点的名称
        self.v_name = name
        # 是否被访问过:False 没有 True:有
        self.visited = False
        # 与此顶点相连接的其它顶点
        self.connected_to = {}

class Graph:

    def __init__(self):
        # 一维列表，保存节点
        self.vert_list = {}
        # 顶点个数
        self.v_nums = 0
        # 使用队列模拟队列或栈，用于路径搜索算法
        self.queue_stack = []
        # 保存搜索到的路径
        self.searchPath = []

class Vertex:
    def __init__(self, v_name, v_id=0):
        # 顶点的编号
        self.v_id = v_id
        # 顶点的名称
        self.v_name = v_name
        # 是否被访问过:False 没有 True:有
        self.visited = False
        # 与此顶点相连接的其它顶点
        self.connected_to = {}

    '''
    添加邻接顶点
    nbr_ver:相邻顶点
    weight:无向无权重图，权重默认设置为 1
    '''
    def add_neighbor(self, nbr_ver, weight=1):
        # 以相邻顶点为键，权重为值
        self.connected_to[nbr_ver] = weight

    '''
    显示与当前顶点相邻的顶点
    '''
    def __str__(self):
        return '与 {0} 顶点相邻的顶点有:{1}'.format(self.v_name,
                                           str([(key.v_name, val) for key, val in self.connected_to.items()]))

    '''
    得到相邻顶点的权重
    '''
    def get_weight(self, nbr_v):
        return self.connected_to[nbr_v]

    '''
    判断给定的顶点是否和当前顶点相邻
    '''
    def is_neighbor(self, nbr_v):
        return nbr_v in self.connected_to     

class Graph:
    def __init__(self):
        # 一维列表，保存节点
        self.vert_list = {}
        # 顶点个数
        self.v_nums = 0
        # 使用队列模拟队列或栈，用于路径搜索算法
        self.queue_stack = []
        # 保存搜索到的路径
        self.searchPath = []

   def add_vertex(self, vert):
        if vert.v_name in self.vert_list:
            # 已经存在
            return
        # 顶点的编号内部生成
        vert.v_id = self.v_nums
        # 所有顶点保存在图所维护的字典中，以顶点名为键，顶点对象为值
        self.vert_list[vert.v_name] = vert
        # 数量增一
        self.v_nums += 1

 	'''
    根据顶点名找到顶点对象
    '''
    def find_vertex(self, v_name):
        if v_name in self.vert_list:
            return self.vert_list.get(v_name)
    # 查询所有顶点
    def find_vertexes(self):
        return [str(ver) for ver in self.vert_list.values()]

    '''
    添加节点与节点之间的关系（边），
    如果是无权重图，统一设定为 1 
    '''
    def add_edge(self, from_v, to_v, weight=1):
        # 如果节点不存在
        if from_v not in self.vert_list:
            self.add_vertex(from_v)
        if to_v not in self.vert_list:
            self.add_vertex(to_v)
        from_v.add_neighbor(to_v, weight)

    '''
    广度优先搜索
    '''
    def bfs_nearest_path(self, from_v, to_v):
        tmp_path = []
        tmp_path.append(from_v)
        # 起始顶点不用压入队列
        from_v.visited = True
        # from_v 顶点的相邻顶点压入队列
        self.push_queue(from_v)
        while len(self.queue_stack) != 0:
            # 从队列中获取顶点
            v_ = self.queue_stack.pop(0)
            if from_v.is_neighbor(v_):
                # 如果 v_ 是 from_v 的后序相邻顶点，则连接成一条中路径信息 
                tmp_path.append(v_)
                # 添加路径信息
                self.searchPath.append(tmp_path)
                tmp_path = tmp_path.copy()
                tmp_path.pop()
            else:
                for path_ in self.searchPath:
                    tmp_path = path_.copy()
                    tmp = tmp_path[len(tmp_path) - 1]
                    if tmp.is_neighbor(v_):
                        tmp_path.append(v_)
                        self.searchPath.append(tmp_path)
            if v_.v_id == to_v.v_id:
                break
            else:
                self.push_queue(v_)

    '''
     把某一顶点的相邻顶点压入队列
     '''
    def push_queue(self, vertex):
        # 获取 vertex 顶点的相邻顶点
        for v_ in vertex.connected_to.keys():
            # 检查此顶点是否压入过
            if v_.visited:
                continue
            vertex.visited = True
            self.queue_stack.append(v_)

'''
测试无向图最短路径
'''

if __name__ == '__main__':
    # 初始化图
    graph = Graph()
    # 添加节点
    for v_name in ['A', 'B', 'C', 'D', 'E', 'F']:
        v = Vertex(v_name)
        graph.add_vertex(v)

    # 添加顶点之间关系
    v_to_v = [('A', 'B'), ('A', 'D'), ('B', 'C'), ('C', 'E'), ('D', 'E'), ('E', 'F')]
    # 无向图中每 2 个相邻顶点之间互为关系
    for v in v_to_v:
        f_v = graph.find_vertex(v[0])
        t_v = graph.find_vertex(v[1])
        graph.add_edge(f_v, t_v)
        graph.add_edge(t_v, f_v)

    # 输出所有顶点
    print('-----------顶点及顶点之间的关系-------------')
    for v in graph.find_vertexes():
        print(v)

    # 查找路径
    print('-------------广度优先搜索--------------------')
    # 起始点
    f_v = graph.find_vertex('A')
    # 目标点
    t_v = graph.find_vertex('F')
    # 广度优先搜索
    graph.bfs_nearest_path(f_v, t_v)
    for path in graph.searchPath:
        weight = 0
        for idx in range(len(path)):
            if idx != len(path) - 1:
                weight += path[idx].get_weight(path[idx + 1])
            print(path[idx].v_name, end='-')
        print("的最短路径长度，", weight)

    '''
    递归实现
    '''

    def bfs_nearest_path_dg(self, from_v, to_v):

        # 相邻顶点
        self.push_queue(from_v)
        tmp_v = self.queue_stack.pop(0)
        if not tmp_v.visited:
            self.searchPath.append(tmp_v)
        if tmp_v.v_id == to_v.v_id:
            return

        self.bfs_nearest_path_dg(tmp_v, to_v)