opencamp-cn#1. [Header部分只有一行，包括三个字段]：type（必需）、scope（必需）和subject（必需）:

opencamp-cn#1.1 <type:commit类型>: 必填项, 指定commit类型:feature/fix/refactor/style(如格式化)/test/build/docs/revert(执行git revert)
opencamp-cn#1.2 <scope1:(JIRA号)>: 对应的Epic/Story/Task等JIRA号, 没有则填"None"
opencamp-cn#1.3 <scope2:[功能模块]>: 必填项, 填写本次改动的功能模块名, 如微服务中module名, 多级module需要填全路径，如paip-common/paip-common-core
opencamp-cn#1.4 <subject:简述>: 必填项, 简述本次提交内容, 如实现了功能名/模块名, 可直接拷贝对应JIRA号的标题
opencamp-cn#2. [Body:详细描述]: 填写详细描述, 主要描述改动之前的情况及修改动机, 对于小的修改不作要求, 但是重大需求更新等必须添加
opencamp-cn#3. [Footer:BREAKING CHANGE]: 当前代码与上一个版本不兼容, 以BREAKING CHANGE开头, 后面是对变动的描述变动理由和迁移方法
fix: 检查代码错误并修复

[详细描述]

#[BREAKING CHANGE]:

Author: Lee Johnson

exercises/easy/algorithm10.rs

@@ -28,37 +28,51 @@ impl Graph for UndirectedGraph {
     fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>> {
         &self.adjacency_table
     }
-    fn add_edge(&mut self, edge: (&str, &str, i32)) {
-        let (from, to, weight) = edge;
-        
-        // 确保两个节点都存在
-        self.add_node(from);
-        self.add_node(to);
-        
-        // 因为是无向图，需要添加双向边
-        self.adjacency_table_mutable()
-            .get_mut(from)
-            .unwrap()
-            .push((to.to_string(), weight));
-            
-        self.adjacency_table_mutable()
-            .get_mut(to)
-            .unwrap()
-            .push((from.to_string(), weight));
+}
+
+impl UndirectedGraph {
+    // 添加一些辅助方法
+    pub fn get_neighbors(&self, node: &str) -> Option<&Vec<(String, i32)>> {
+        self.adjacency_table.get(node)
+    }
+
+    pub fn node_count(&self) -> usize {
+        self.adjacency_table.len()
+    }
+
+    pub fn edge_count(&self) -> usize {
+        self.edges().len() / 2  // 因为是无向图，每条边都被计算了两次
     }
 }
+
 pub trait Graph {
     fn new() -> Self;
     fn adjacency_table_mutable(&mut self) -> &mut HashMap<String, Vec<(String, i32)>>;
     fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>>;
     fn add_node(&mut self, node: &str) -> bool {
-        if self.contains(node) {
-            return false;
+        if self.adjacency_table_mutable().contains_key(node) {
+            return true;
         }
-        self.adjacency_table_mutable().insert(node.to_string(), Vec::new());
+        self.adjacency_table_mutable().insert(String::from(node), vec![]);
         true
     }
-    fn add_edge(&mut self, edge: (&str, &str, i32));
+    fn add_edge(&mut self, edge: (&str, &str, i32)) {
+        let (from, to, weight) = edge;
+        if !self.contains(from) {
+            self.add_node(from);
+        }
+        if !self.contains(to) {
+            self.add_node(to);
+        }
+        self.adjacency_table_mutable()
+            .get_mut(from)
+            .unwrap()
+            .push((String::from(to), weight));
+        self.adjacency_table_mutable()
+            .get_mut(to)
+            .unwrap()
+            .push((String::from(from), weight));
+    }
     fn contains(&self, node: &str) -> bool {
         self.adjacency_table().get(node).is_some()
     }
@@ -97,4 +111,4 @@ mod test_undirected_graph {
             assert_eq!(graph.edges().contains(edge), true);
         }
     }
-}
+}

exercises/easy/algorithm4.rs

@@ -58,14 +58,14 @@ where
 
     // Search for a value in the BST
     fn search(&self, value: T) -> bool {
-        fn search_internal<T: Ord>(node: &Option<Box<TreeNode<T>>>, value: &T) -> bool {
+        fn search_internal<T: Ord>(node: &Option<Box<TreeNode<T>>>, target: &T) -> bool {
             match node {
                 None => false,
                 Some(node) => {
-                    match value.cmp(&node.value) {
+                    match target.cmp(&node.value) {
                         Ordering::Equal => true,
-                        Ordering::Less => search_internal(&node.left, value),
-                        Ordering::Greater => search_internal(&node.right, value),
+                        Ordering::Less => search_internal(&node.left, target),
+                        Ordering::Greater => search_internal(&node.right, target),
                     }
                 }
             }
@@ -81,19 +81,23 @@ where
     // Insert a node into the tree
     fn insert(&mut self, value: T) {
         match value.cmp(&self.value) {
+            Ordering::Equal => return, // 重复值不插入，直接返回
             Ordering::Less => {
-                match &mut self.left {
-                    None => self.left = Some(Box::new(TreeNode::new(value))),
-                    Some(node) => node.insert(value),
+                // 插入到左子树
+                if self.left.is_none() {
+                    self.left = Some(Box::new(TreeNode::new(value)));
+                } else {
+                    self.left.as_mut().unwrap().insert(value);
                 }
             }
             Ordering::Greater => {
-                match &mut self.right {
-                    None => self.right = Some(Box::new(TreeNode::new(value))),
-                    Some(node) => node.insert(value),
+                // 插入到右子树
+                if self.right.is_none() {
+                    self.right = Some(Box::new(TreeNode::new(value)));
+                } else {
+                    self.right.as_mut().unwrap().insert(value);
                 }
             }
-            Ordering::Equal => {} // 如果值相等，不做任何操作（避免重复）
         }
     }
 }
@@ -149,4 +153,6 @@ mod tests {
             None => panic!("Root should not be None after insertion"),
         }
     }
-}
+}    
+
+