build

chapter_graph/graph_operations.md

@@ -213,7 +213,78 @@ comments: true
 === "Python"
 
     ```python title="graph_adjacency_matrix.py"
-    [class]{GraphAdjMat}-[func]{}
+    """ 基于邻接矩阵实现的无向图类 """
+    class GraphAdjMat:
+        # 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+        vertices = []
+        # 邻接矩阵，行列索引对应“顶点索引”
+        adj_mat = []
+
+        """ 构造方法 """
+        def __init__(self, vertices, edges):
+            self.vertices = []
+            self.adj_mat = []
+            # 添加顶点
+            for val in vertices:
+                self.add_vertex(val)
+            # 添加边
+            # 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+            for e in edges:
+                self.add_edge(e[0], e[1])
+
+        """ 获取顶点数量 """
+        def size(self):
+            return len(self.vertices)
+
+        """ 添加顶点 """
+        def add_vertex(self, val):
+            n = self.size()
+            # 向顶点列表中添加新顶点的值
+            self.vertices.append(val)
+            # 在邻接矩阵中添加一行
+            new_row = [0]*n
+            self.adj_mat.append(new_row)
+            # 在邻接矩阵中添加一列
+            for row in self.adj_mat:
+                row.append(0)
+
+
+        """ 删除顶点 """
+        def remove_vertex(self, index):
+            if index >= self.size():
+                raise IndexError()
+            # 在顶点列表中移除索引 index 的顶点
+            self.vertices.pop(index)
+            # 在邻接矩阵中删除索引 index 的行
+            self.adj_mat.pop(index)
+            # 在邻接矩阵中删除索引 index 的列
+            for row in self.adj_mat:
+                row.pop(index)
+
+        """ 添加边 """
+        # 参数 i, j 对应 vertices 元素索引
+        def add_edge(self, i, j):
+            # 索引越界与相等处理
+            if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
+                raise IndexError()
+            # 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
+            self.adj_mat[i][j] = 1
+            self.adj_mat[j][i] = 1
+
+        """ 删除边 """
+        # 参数 i, j 对应 vertices 元素索引
+        def remove_edge(self, i, j):
+            # 索引越界与相等处理
+            if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
+                raise IndexError()
+            self.adj_mat[i][j] = 0
+            self.adj_mat[j][i] = 0
+
+        """ 打印邻接矩阵 """
+        def print(self):
+            print("顶点列表 =", self.vertices)
+            print("邻接矩阵 =")
+            print_matrix(self.adj_mat)
     ```
 
 === "Go"
@@ -887,7 +958,64 @@ comments: true
 === "Python"
 
     ```python title="graph_adjacency_list.py"
-    [class]{GraphAdjList}-[func]{}
+    """ 基于邻接表实现的无向图类 """
+    class GraphAdjList:
+        # 邻接表，key: 顶点，value：该顶点的所有邻接结点
+        adj_list = {}
+
+        """ 构造方法 """
+        def __init__(self, edges: List[List[Vertex]]) -> None:
+            self.adj_list = {}
+            # 添加所有顶点和边
+            for edge in edges:
+                self.add_vertex(edge[0])
+                self.add_vertex(edge[1])
+                self.add_edge(edge[0], edge[1])
+
+        """ 获取顶点数量 """
+        def size(self) -> int:
+            return len(self.adj_list)
+
+        """ 添加边 """
+        def add_edge(self, vet1: Vertex, vet2: Vertex) -> None:
+            if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:
+                raise ValueError
+            # 添加边 vet1 - vet2
+            self.adj_list[vet1].append(vet2)
+            self.adj_list[vet2].append(vet1)
+
+        """ 删除边 """
+        def remove_edge(self, vet1: Vertex, vet2: Vertex) -> None:
+            if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:
+                raise ValueError
+            # 删除边 vet1 - vet2
+            self.adj_list[vet1].remove(vet2)
+            self.adj_list[vet2].remove(vet1)
+
+        """ 添加顶点 """
+        def add_vertex(self, vet: Vertex) -> None:
+            if vet in self.adj_list:
+                return
+            # 在邻接表中添加一个新链表
+            self.adj_list[vet] = []
+
+        """ 删除顶点 """
+        def remove_vertex(self, vet: Vertex) -> None:
+            if vet not in self.adj_list:
+                raise ValueError
+            # 在邻接表中删除顶点 vet 对应的链表
+            self.adj_list.pop(vet)
+            # 遍历其它顶点的链表，删除所有包含 vet 的边
+            for vertex in self.adj_list:
+                if vet in self.adj_list[vertex]:
+                    self.adj_list[vertex].remove(vet)
+
+        """ 打印邻接表 """
+        def print(self) -> None:
+            print("邻接表 =")
+            for vertex in self.adj_list:
+                tmp = [v.val for v in self.adj_list[vertex]]
+                print(f"{vertex.val}: {tmp},")
     ```
 
 === "Go"
@@ -1246,10 +1374,10 @@ comments: true
     class GraphAdjList {
         // 邻接表，使用哈希表来代替链表，以提升删除边、删除顶点的效率
         // 请注意，adjList 中的元素是 Vertex 对象
-        private var adjList: [Vertex: [Vertex]]
+        public private(set) var adjList: [Vertex: [Vertex]]
 
         /* 构造方法 */
-        init(edges: [[Vertex]]) {
+        public init(edges: [[Vertex]]) {
             adjList = [:]
             // 添加所有顶点和边
             for edge in edges {
@@ -1260,12 +1388,12 @@ comments: true
         }
 
         /* 获取顶点数量 */
-        func size() -> Int {
+        public func size() -> Int {
             adjList.count
         }
 
         /* 添加边 */
-        func addEdge(vet1: Vertex, vet2: Vertex) {
+        public func addEdge(vet1: Vertex, vet2: Vertex) {
             if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {
                 fatalError("参数错误")
             }
@@ -1275,7 +1403,7 @@ comments: true
         }
 
         /* 删除边 */
-        func removeEdge(vet1: Vertex, vet2: Vertex) {
+        public func removeEdge(vet1: Vertex, vet2: Vertex) {
             if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {
                 fatalError("参数错误")
             }
@@ -1285,7 +1413,7 @@ comments: true
         }
 
         /* 添加顶点 */
-        func addVertex(vet: Vertex) {
+        public func addVertex(vet: Vertex) {
             if adjList[vet] != nil {
                 return
             }
@@ -1294,7 +1422,7 @@ comments: true
         }
 
         /* 删除顶点 */
-        func removeVertex(vet: Vertex) {
+        public func removeVertex(vet: Vertex) {
             if adjList[vet] == nil {
                 fatalError("参数错误")
             }
@@ -1307,7 +1435,7 @@ comments: true
         }
 
         /* 打印邻接表 */
-        func print() {
+        public func print() {
             Swift.print("邻接表 =")
             for entry in adjList {
                 var tmp: [Int] = []

chapter_graph/graph_traversal.md

@@ -66,7 +66,27 @@ BFS 常借助「队列」来实现。队列具有“先入先出”的性质，
 === "Python"
 
     ```python title="graph_bfs.py"
-
+    """ 广度优先遍历 BFS """
+    # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> List[Vertex]:
+        # 顶点遍历序列
+        res = []
+        # 哈希表，用于记录已被访问过的顶点
+        visited = set([start_vet])
+        # 队列用于实现 BFS
+        que = collections.deque([start_vet])
+        # 以顶点 vet 为起点，循环直至访问完所有顶点
+        while len(que) > 0:
+            vet = que.popleft()  # 队首顶点出队
+            res.append(vet)      # 记录访问顶点
+            # 遍历该顶点的所有邻接顶点
+            for adj_vet in graph.adj_list[vet]:
+                if adj_vet in visited:
+                    continue         # 跳过已被访问过的顶点
+                que.append(adj_vet)  # 只入队未访问的顶点
+                visited.add(adj_vet) # 标记该顶点已被访问
+        # 返回顶点遍历序列
+        return res
     ```
 
 === "Go"
@@ -102,7 +122,31 @@ BFS 常借助「队列」来实现。队列具有“先入先出”的性质，
 === "Swift"
 
     ```swift title="graph_bfs.swift"
-
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphBFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+        // 顶点遍历序列
+        var res: [Vertex] = []
+        // 哈希表，用于记录已被访问过的顶点
+        var visited: Set<Vertex> = [startVet]
+        // 队列用于实现 BFS
+        var que: [Vertex] = [startVet]
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while !que.isEmpty {
+            let vet = que.removeFirst() // 队首顶点出队
+            res.append(vet) // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for adjVet in graph.adjList[vet] ?? [] {
+                if visited.contains(adjVet) {
+                    continue // 跳过已被访问过的顶点
+                }
+                que.append(adjVet) // 只入队未访问的顶点
+                visited.insert(adjVet) // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res
+    }
     ```
 
 === "Zig"
@@ -203,7 +247,26 @@ BFS 常借助「队列」来实现。队列具有“先入先出”的性质，
 === "Python"
 
     ```python title="graph_dfs.py"
+    """ 深度优先遍历 DFS 辅助函数 """
+    def dfs(graph: GraphAdjList, visited: Set[Vertex], res: List[Vertex], vet: Vertex):
+        res.append(vet)     # 记录访问顶点
+        visited.add(vet) # 标记该顶点已被访问
+        # 遍历该顶点的所有邻接顶点
+        for adjVet in graph.adj_list[vet]:
+            if adjVet in visited:
+                continue # 跳过已被访问过的顶点
+            # 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet)
 
+    """ 深度优先遍历 DFS """
+    # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    def graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> List[Vertex]:
+        # 顶点遍历序列
+        res = []
+        # 哈希表，用于记录已被访问过的顶点
+        visited = set()
+        dfs(graph, visited, res, start_vet)
+        return res
     ```
 
 === "Go"
@@ -239,7 +302,30 @@ BFS 常借助「队列」来实现。队列具有“先入先出”的性质，
 === "Swift"
 
     ```swift title="graph_dfs.swift"
+    /* 深度优先遍历 DFS 辅助函数 */
+    func dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {
+        res.append(vet) // 记录访问顶点
+        visited.insert(vet) // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for adjVet in graph.adjList[vet] ?? [] {
+            if visited.contains(adjVet) {
+                continue // 跳过已被访问过的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph: graph, visited: &visited, res: &res, vet: adjVet)
+        }
+    }
 
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphDFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+        // 顶点遍历序列
+        var res: [Vertex] = []
+        // 哈希表，用于记录已被访问过的顶点
+        var visited: Set<Vertex> = []
+        dfs(graph: graph, visited: &visited, res: &res, vet: startVet)
+        return res
+    }
     ```
 
 === "Zig"