图、深度优先（DFS）、广度优先（BFS）

图

基本介绍

表示方式

图的创建

from typing import List


class Graph:
    vertex_list: List[str] = []  # 存储顶点的数组
    edges: List[list] = []  # 存储图中各条边的邻接矩阵
    num_edges: int = 0  # 边的数总数

    def __init__(self, n: int):
        """
        根据传入的顶点个数初始化顶点数组和邻接矩阵
        n: 图中的顶点个数
        """
        for i in range(n):
            arr = []
            for j in range(n):
                arr.append(0)
            self.edges.append(arr)

    def insert_vertex(self, vertex_val: str):
        """
        添加顶点
        vertex_val: 顶点的值
        """
        self.vertex_list.append(vertex_val)

    def insert_edge(self, v1: int, v2: int, weight: int = 0):
        """
        添加边
        v1: 边的起始顶点的下标，从0开始
        v2: 边的结束顶点的下标，从0开始
        weight: 权值，为1表示两个顶点之间存在边，为0表示两个顶点没有边
        如 A——B ，v1 表示顶点A的下标0，v2表示顶点B的下标1，
        AB之间存在边，所以weight=1
        """
        # 因为是无向图，所以两个顶点对应的位置都要设置边
        self.edges[v1][v2] = weight
        self.edges[v2][v1] = weight
        self.num_edges += 1  # 边的数量加1

    def show_graph(self):
        """
        遍历邻接矩阵
        """
        for arr in self.edges:
            for i in arr:
                print(i, end=' ')
            print()

    def get_num_vertex(self) -> int:
        """
        返回图中的顶点个数
        """
        return len(self.vertex_list)

    def get_num_edge(self) -> int:
        """
        返回图中边的数量
        """
        return self.num_edges

    def get_vertex_val_by_index(self, i: int) -> str:
        """
        根据顶点下标返回顶点的值
        如传入下标0，返回A
        """
        return self.vertex_list[i]

    def get_weight(self, v1: int, v2: int) -> int:
        """
        返回两个顶点之间边的权值
        """
        return self.edges[v1][v2]


def test_graph():
    n = 5
    vertex_arr = ['A', 'B', 'C', 'D', 'E']
    graph = Graph(n)

    # 向图中循环添加顶点
    for i in vertex_arr:
        graph.insert_vertex(i)

    # 添加边
    graph.insert_edge(0, 1, 1)
    graph.insert_edge(0, 2, 1)
    graph.insert_edge(1, 2, 1)
    graph.insert_edge(1, 3, 1)
    graph.insert_edge(1, 4, 1)
    # 显示图的邻接矩阵
    graph.show_graph()


test_graph()

图的深度优先遍历

基本介绍

代码实现

from typing import List


class Graph:
    vertex_list: List[str] = []  # 存储顶点的数组
    edges: List[list] = []  # 存储图中各条边的邻接矩阵
    num_edges: int = 0  # 边的数总数
    is_visited: List[bool] = []  # 标记一个节点是否被访问

    def __init__(self, n: int):
        """
        根据传入的顶点个数初始化顶点数组和邻接矩阵
        n: 图中的顶点个数
        """
        for i in range(n):
            arr = []
            for j in range(n):
                arr.append(0)
            self.edges.append(arr)
            self.is_visited.append(False)

    def get_first_neighbor(self, index: int):
        """
        返回节点第一个邻接节点的下标，如果节点没有邻接节点则返回-1
        """
        for i in range(len(self.vertex_list)):
            if self.edges[index][i] > 0:
                return i

        return -1

    def get_next_neighbor(self, v1: int, v2: int):
        """
        根据节点v1的前一个邻接节点的下标v2获取节点v1的下一个邻接节点的下标
        """
        for i in range(v2 + 1, len(self.vertex_list)):
            if self.edges[v1][i] > 0:
                return i

        return -1

    def dfs(self, i: int):
        """
        深度优先遍历
        :param i: 从节点i开始遍历
        :return:
        """
        # 访问节点i，即输出它
        print(self.vertex_list[i], end=' -> ')
        self.is_visited[i] = True
        # 获取节点i的下一个邻接节点
        w = self.get_first_neighbor(i)
        # 如果节点i的下一个邻接节点w存在
        while w != -1:
            if not self.is_visited[w]:  # 如果w没有被访问过，则从节点w开始继续深度遍历
                self.dfs(w)
            # 如果w已经被访问过，则从节点i的另一个邻接点开始遍历
            w = self.get_next_neighbor(i, w)
        # 如果w不存在，则回退到节点v，遍历节点v的下一个邻接点
        # 所谓的回溯，就是返回到调用dfs()的地方继续执行

    def for_dfs(self):
        """
        遍历所有顶点，看是否存在没有访问过的节点
        """
        for i in range(self.get_num_vertex()):
            if not self.is_visited[i]:  # 存在没有访问过的节点，以该节点进行深度优先遍历
                self.dfs(i)

    def insert_vertex(self, vertex_val: str):
        """
        添加顶点
        vertex_val: 顶点的值
        """
        self.vertex_list.append(vertex_val)

    def insert_edge(self, v1: int, v2: int, weight: int = 0):
        """
        添加边
        v1: 边的起始顶点的下标，从0开始
        v2: 边的结束顶点的下标，从0开始
        weight: 权值，为1表示两个顶点之间存在边，为0表示两个顶点没有边
        如 A——B ，v1 表示顶点A的下标0，v2表示顶点B的下标1，
        AB之间存在边，所以weight=1
        """
        # 因为是无向图，所以两个顶点对应的位置都要设置边
        self.edges[v1][v2] = weight
        self.edges[v2][v1] = weight
        self.num_edges += 1  # 边的数量加1

    def show_graph(self):
        """
        遍历邻接矩阵
        """
        for arr in self.edges:
            for i in arr:
                print(i, end=' ')
            print()

    def get_num_vertex(self) -> int:
        """
        返回图中的顶点个数
        """
        return len(self.vertex_list)


def test_graph():
    n = 5
    vertex_arr = ['A', 'B', 'C', 'D', 'E']
    graph = Graph(n)

    # 向图中循环添加顶点
    for i in vertex_arr:
        graph.insert_vertex(i)

    # 添加边
    graph.insert_edge(0, 1, 1)
    graph.insert_edge(0, 2, 1)
    graph.insert_edge(1, 2, 1)
    graph.insert_edge(1, 3, 1)
    graph.insert_edge(1, 4, 1)
    # 显示图的邻接矩阵
    graph.show_graph()
    print("深度优先遍历：", end='')
    graph.for_dfs()


test_graph()

图的广度优先遍历

基本介绍

代码实现

from typing import List


class Graph:
    vertex_list: List[str] = []  # 存储顶点的数组
    edges: List[list] = []  # 存储图中各条边的邻接矩阵
    num_edges: int = 0  # 边的数总数
    is_visited: List[bool] = []  # 标记一个节点是否被访问

    def __init__(self, n: int):
        """
        根据传入的顶点个数初始化顶点数组和邻接矩阵
        n: 图中的顶点个数
        """
        for i in range(n):
            arr = []
            for j in range(n):
                arr.append(0)
            self.edges.append(arr)
            self.is_visited.append(False)

    def get_first_neighbor(self, index: int):
        """
        返回节点第一个邻接节点的下标，如果节点没有邻接节点则返回-1
        """
        for i in range(len(self.vertex_list)):
            if self.edges[index][i] > 0:
                return i

        return -1

    def get_next_neighbor(self, v1: int, v2: int):
        """
        根据节点v1的前一个邻接节点的下标v2获取节点v1的下一个邻接节点的下标
        """
        for i in range(v2 + 1, len(self.vertex_list)):
            if self.edges[v1][i] > 0:
                return i

        return -1

    def bfs(self, i: int):
        """
        对一个节点进行广度优先遍历
        :param i: 节点的下标
        """
        que = []  # 用列表模拟队列，存储已访问过的节点
        # 输出节点信息
        print(self.vertex_list[i], end=' -> ')
        # 标记节点为已访问
        self.is_visited[i] = True
        que.append(i)  # 将已访问过的节点的下标加入队列
        while que:  # 队列不为空，对节点i的广度优先遍历就继续
            # 取出队头节点的下标u
            u = que.pop(0)
            # 获取节点u的第一个邻接节点的下标w
            w = self.get_first_neighbor(u)
            # 如果节点w存在
            while w != -1:
                # 如果节点w未被访问，则访问并将节点w入队
                if not self.is_visited[w]:
                    print(self.vertex_list[w], end=' -> ')
                    self.is_visited[w] = True
                    que.append(w)
                # 查找节点u继节点w后的另一个邻接节点
                w = self.get_next_neighbor(u, w)

    def for_bfs(self):
        """
        遍历所有顶点，看还有哪一个没有访问过，如果有，则从没有访问过的顶点开始广度优先遍历
        :return:
        """
        for i in range(len(self.vertex_list)):
            if not self.is_visited[i]:
                self.bfs(i)

    def insert_vertex(self, vertex_val: str):
        """
        添加顶点
        vertex_val: 顶点的值
        """
        self.vertex_list.append(vertex_val)

    def insert_edge(self, v1: int, v2: int, weight: int = 0):
        """
        添加边
        v1: 边的起始顶点的下标，从0开始
        v2: 边的结束顶点的下标，从0开始
        weight: 权值，为1表示两个顶点之间存在边，为0表示两个顶点没有边
        如 A——B ，v1 表示顶点A的下标0，v2表示顶点B的下标1，
        AB之间存在边，所以weight=1
        """
        # 因为是无向图，所以两个顶点对应的位置都要设置边
        self.edges[v1][v2] = weight
        self.edges[v2][v1] = weight
        self.num_edges += 1  # 边的数量加1

    def show_graph(self):
        """
        遍历邻接矩阵
        """
        for arr in self.edges:
            for i in arr:
                print(i, end=' ')
            print()


def test_graph():
    n = 5
    vertex_arr = ['A', 'B', 'C', 'D', 'E']
    graph = Graph(n)

    # 向图中循环添加顶点
    for i in vertex_arr:
        graph.insert_vertex(i)

    # 添加边
    graph.insert_edge(0, 1, 1)
    graph.insert_edge(0, 2, 1)
    graph.insert_edge(1, 2, 1)
    graph.insert_edge(1, 3, 1)
    graph.insert_edge(1, 4, 1)
    # 显示图的邻接矩阵
    graph.show_graph()
    print("广度优先遍历：", end='')
    graph.for_bfs()


test_graph()