build

chapter_graph/graph_operations.md

@@ -1021,6 +1021,107 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="graph_adjacency_matrix.rs"
+    /* 基于邻接矩阵实现的无向图类型 */
+    pub struct GraphAdjMat {
+        // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+        pub vertices: Vec<i32>,
+        // 邻接矩阵，行列索引对应“顶点索引”
+        pub adj_mat: Vec<Vec<i32>>,
+    }
+
+    impl GraphAdjMat {
+        /* 构造方法 */
+        pub fn new(vertices: Vec<i32>, edges: Vec<[usize; 2]>) -> Self {
+            let mut graph = GraphAdjMat {
+                vertices: vec![],
+                adj_mat: vec![],
+            };
+            // 添加顶点
+            for val in vertices {
+                graph.add_vertex(val);
+            }
+            // 添加边
+            // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+            for edge in edges {
+                graph.add_edge(edge[0], edge[1])
+            }
+
+            graph
+        }
+
+        /* 获取顶点数量 */
+        pub fn size(&self) -> usize {
+            self.vertices.len()
+        }
+
+        /* 添加顶点 */
+        pub fn add_vertex(&mut self, val: i32) {
+            let n = self.size();
+            // 向顶点列表中添加新顶点的值
+            self.vertices.push(val);
+            // 在邻接矩阵中添加一行
+            self.adj_mat.push(vec![0; n]);
+            // 在邻接矩阵中添加一列
+            for row in &mut self.adj_mat {
+                row.push(0);
+            }
+        }
+
+        /* 删除顶点 */
+        pub fn remove_vertex(&mut self, index: usize) {
+            if index >= self.size() {
+                panic!("index error")
+            }
+            // 在顶点列表中移除索引 index 的顶点
+            self.vertices.remove(index);
+            // 在邻接矩阵中删除索引 index 的行
+            self.adj_mat.remove(index);
+            // 在邻接矩阵中删除索引 index 的列
+            for row in &mut self.adj_mat {
+                row.remove(index);
+            }
+        }
+
+        /* 添加边 */
+        pub fn add_edge(&mut self, i: usize, j: usize) {
+            // 参数 i, j 对应 vertices 元素索引
+            // 索引越界与相等处理
+            if i >= self.size() || j >= self.size() || i == j {
+                panic!("index error")
+            }
+            // 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
+            self.adj_mat[i][j] = 1;
+            self.adj_mat[j][i] = 1;
+        }
+
+        /* 删除边 */
+        // 参数 i, j 对应 vertices 元素索引
+        pub fn remove_edge(&mut self, i: usize, j: usize) {
+            // 参数 i, j 对应 vertices 元素索引
+            // 索引越界与相等处理
+            if i >= self.size() || j >= self.size() || i == j {
+                panic!("index error")
+            }
+            self.adj_mat[i][j] = 0;
+            self.adj_mat[j][i] = 0;
+        }
+
+        /* 打印邻接矩阵 */
+        pub fn print(&self) {
+            println!("顶点列表 = {:?}", self.vertices);
+            println!("邻接矩阵 =");
+            println!("[");
+            for row in &self.adj_mat {
+                println!("  {:?},", row);
+            }
+            println!("]")
+        }
+    }
+    ```
+
 ## 9.2.2. &nbsp; 基于邻接表的实现
 
 设无向图的顶点总数为 $n$ 、边总数为 $m$ ，则有：
@@ -1913,6 +2014,100 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="graph_adjacency_list.rs"
+    /* 基于邻接表实现的无向图类型 */
+    pub struct GraphAdjList {
+        // 邻接表，key: 顶点，value：该顶点的所有邻接顶点
+        pub adj_list: HashMap<Vertex, Vec<Vertex>>,
+    }
+
+    impl GraphAdjList {
+        /* 构造方法 */
+        pub fn new(edges: Vec<[Vertex; 2]>) -> Self {
+            let mut graph = GraphAdjList {
+                adj_list: HashMap::new(),
+            };
+            // 添加所有顶点和边
+            for edge in edges {
+                graph.add_vertex(edge[0]);
+                graph.add_vertex(edge[1]);
+                graph.add_edge(edge[0], edge[1]);
+            }
+
+            graph
+        }
+
+        /* 获取顶点数量 */
+        #[allow(unused)]
+        pub fn size(&self) -> usize {
+            self.adj_list.len()
+        }
+
+        /* 添加边 */
+        pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {
+            if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
+            {
+                panic!("value error");
+            }
+            // 添加边 vet1 - vet2
+            self.adj_list.get_mut(&vet1).unwrap().push(vet2);
+            self.adj_list.get_mut(&vet2).unwrap().push(vet1);
+        }
+
+        /* 删除边 */
+        #[allow(unused)]
+        pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {
+            if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
+            {
+                panic!("value error");
+            }
+            // 删除边 vet1 - vet2
+            self.adj_list
+                .get_mut(&vet1)
+                .unwrap()
+                .retain(|&vet| vet != vet2);
+            self.adj_list
+                .get_mut(&vet2)
+                .unwrap()
+                .retain(|&vet| vet != vet1);
+        }
+
+        /* 添加顶点 */
+        pub fn add_vertex(&mut self, vet: Vertex) {
+            if self.adj_list.contains_key(&vet) {
+                return;
+            }
+            // 在邻接表中添加一个新链表
+            self.adj_list.insert(vet, vec![]);
+        }
+
+        /* 删除顶点 */
+        #[allow(unused)]
+        pub fn remove_vertex(&mut self, vet: Vertex) {
+            if !self.adj_list.contains_key(&vet) {
+                panic!("value error");
+            }
+            // 在邻接表中删除顶点 vet 对应的链表
+            self.adj_list.remove(&vet);
+            // 遍历其他顶点的链表，删除所有包含 vet 的边
+            for list in self.adj_list.values_mut() {
+                list.retain(|&v| v != vet);
+            }
+        }
+
+        /* 打印邻接表 */
+        pub fn print(&self) {
+            println!("邻接表 =");
+            for (vertex, list) in &self.adj_list {
+                let list = list.iter().map(|vertex| vertex.val).collect::<Vec<i32>>();
+                println!("{}: {:?},", vertex.val, list);
+            }
+        }
+    }
+    ```
+
 ## 9.2.3. &nbsp; 效率对比
 
 设图中共有 $n$ 个顶点和 $m$ 条边，下表为邻接矩阵和邻接表的时间和空间效率对比。

chapter_graph/graph_traversal.md

@@ -358,6 +358,40 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质
     }
     ```
 
+=== "Rust"
+
+    ```rust title="graph_bfs.rs"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    fn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+        // 顶点遍历序列
+        let mut res = vec![];
+        // 哈希表，用于记录已被访问过的顶点
+        let mut visited = HashSet::new();
+        visited.insert(start_vet);
+        // 队列用于实现 BFS
+        let mut que = VecDeque::new();
+        que.push_back(start_vet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while !que.is_empty() {
+            let vet = que.pop_front().unwrap(); // 队首顶点出队
+            res.push(vet); // 记录访问顶点
+                        // 遍历该顶点的所有邻接顶点
+            if let Some(adj_vets) = graph.adj_list.get(&vet) {
+                for &adj_vet in adj_vets {
+                    if visited.contains(&adj_vet) {
+                        continue; // 跳过已被访问过的顶点
+                    }
+                    que.push_back(adj_vet); // 只入队未访问的顶点
+                    visited.insert(adj_vet); // 标记该顶点已被访问
+                }
+            }
+        }
+        // 返回顶点遍历序列
+        res
+    }
+    ```
+
 代码相对抽象，建议对照以下动画图示来加深理解。
 
 === "<1>"
@@ -729,6 +763,38 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质
     }
     ```
 
+=== "Rust"
+
+    ```rust title="graph_dfs.rs"
+    /* 深度优先遍历 DFS 辅助函数 */
+    fn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {
+        res.push(vet); // 记录访问顶点
+        visited.insert(vet); // 标记该顶点已被访问
+                             // 遍历该顶点的所有邻接顶点
+        if let Some(adj_vets) = graph.adj_list.get(&vet) {
+            for &adj_vet in adj_vets {
+                if visited.contains(&adj_vet) {
+                    continue; // 跳过已被访问过的顶点
+                }
+                // 递归访问邻接顶点
+                dfs(graph, visited, res, adj_vet);
+            }
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    fn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+        // 顶点遍历序列
+        let mut res = vec![];
+        // 哈希表，用于记录已被访问过的顶点
+        let mut visited = HashSet::new();
+        dfs(&graph, &mut visited, &mut res, start_vet);
+
+        res
+    }
+    ```
+
 深度优先遍历的算法流程如下图所示，其中：
 
 - **直虚线代表向下递推**，表示开启了一个新的递归方法来访问新顶点。