一个无向图有四个顶点_无向图的深度优先搜索和广度优先搜索

# 无向图（深度优先搜索）
class Graph(object):
    def __init__(self):
        self.v = 0  # 顶点数目
        self.e = 0  # 边数目
        self.adj_list = {}  # 邻接表，用字典实现
        self.marked = [0]*self.v  # 标记列表
        self.v_list = []  # 与s连通的所有顶点
        self.paths = {}  # 记录所有起点为s的路径

    def add_v(self, v):  # 添加顶点
        if v not in self.adj_list.keys():
            self.adj_list[v] = []
            self.v += 1

    def add_vlist(self, vlist):  # 添加多个顶点
        for v in vlist:
            self.add_v(v)

    def add_edge(self, e):  # 添加边
        u, v = e
        if v not in self.adj_list[u]:
            self.adj_list[u].append(v)
        if u not in self.adj_list[v]:
            self.adj_list[v].append(u)

    def depth_first_search(self, s):  # 深度优先搜索，全范围搜索，返回所有与s连通的顶点
        self.marked = [0]*self.v
        self.v_list = []  # 与s连通的所有顶点
        self.dfs(s)
        return self.v_list

    def dfs(self, s):
        self.marked[s] = 1
        if s not in self.v_list:
            self.v_list.append(s)
        for i in self.adj_list[s]:
            if self.marked[i] == 0:
                self.dfs(i)

    def depth_first_paths(self, s):  # 搜索所有与以s为起点的路径
        self.marked = [0] * self.v
        for i in self.v_list:
            self.paths[i] = []
        self.paths[s] = [s]
        self.dfs_p(s)
        return self.paths

    def dfs_p(self, s):
        self.marked[s] = 1
        # 每遍历到一个节点，将【父节点的路径+此节点】作为->该节点s的路径
        for i in self.adj_list[s]:
            if self.marked[i] == 0:
                self.paths[i] += self.paths[s]
                self.paths[i].append(i)
                self.dfs_p(i)

    def has_path_to(self, v):  # 是否存在从s（起点）到v的路径
        return self.marked[v]

        # for i in self.adj_list[s]:
        #     if self.marked[i] == 0:
        #         self.paths[i].append(i)
        #         for j in self.adj_list[i]:
        #             if self.marked[j] == 0:
        #                 # 如果h节点不在路径中，则添加进路径
        #                 for h in self.paths[i]:
        #                     if h not in self.paths[j]:
        #                         self.paths[j].append(h)
        #         self.dfs_p(i)

# graph = Graph()
# graph.add_vlist([0, 1, 2, 3, 4, 5])
# graph.add_edge([0,2])
# graph.add_edge([0,5])
# graph.add_edge([0,1])
# graph.add_edge([1,2])
# graph.add_edge([1,0])
# graph.add_edge([2,3])
# graph.add_edge([2,1])
# graph.add_edge([2,4])
# graph.add_edge([3,2])
# graph.add_edge([3,5])
# graph.add_edge([3,4])
# graph.add_edge([5,0])
# graph.add_edge([5,3])
#
# print(graph.depth_first_search(0))
# print(graph.adj_list)
# print(graph.marked)
# print(graph.v)
# print(graph.depth_first_paths(0))
# print(graph.has_path_to(4))


# 无向图（广度优先搜索）
class BreadthFirstPaths(Graph):  # 类继承
    def __init__(self):
        Graph.__init__(self)
        self.queue = []  # 用来存放所有已被标记过但其邻接表还有未被检查过的顶点

    def breadth_first_paths(self, s):  # 广度优先搜索，返回以所有s为起点的最短路径
        self.v_list = self.depth_first_search(s)  # 所有与s连通的顶点
        self.marked = [0] * self.v
        for i in self.v_list:
            self.paths[i] = []
        self.paths[s] = [s]
        self.bfs(s)
        return self.paths

    def bfs(self, s):
        self.marked[s] = 1
        self.queue.append(s)

        while not self.isEmpty(self.queue):
            v = self.queue.pop(0)
            for i in self.adj_list[v]:
                if self.marked[i] == 0:
                    self.paths[i] += self.paths[v]
                    self.paths[i].append(i)
                    self.marked[i] = 1
                    self.queue.append(i)

    def isEmpty(self, q):
        return len(q) == 0