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$ 条边，下表为邻接矩阵和邻接表的时间和空间效率对比。