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开头, 后面是对变动的描述变动理由和迁移方法
feature: 根据注释要求，完成所有功能

[详细描述]

#[BREAKING CHANGE]:

Author: Lee Johnson

exercises/easy/algorithm1.rs

@@ -69,14 +69,42 @@ impl<T> LinkedList<T> {
             },
         }
     }
-	pub fn merge(list_a:LinkedList<T>,list_b:LinkedList<T>) -> Self
+	pub fn merge(list_a: LinkedList<T>, list_b: LinkedList<T>) -> Self
+	where
+		T: Ord,
 	{
-		//TODO
-		Self {
-            length: 0,
-            start: None,
-            end: None,
-        }
+		let mut merged = LinkedList::new();
+		let mut current_a = list_a.start;
+		let mut current_b = list_b.start;
+		
+		// 同时遍历两个链表，比较并添加较小的节点
+		while let (Some(ptr_a), Some(ptr_b)) = (current_a, current_b) {
+			let node_a = unsafe { &*ptr_a.as_ptr() };
+			let node_b = unsafe { &*ptr_b.as_ptr() };
+			
+			if node_a.val <= node_b.val {
+				merged.add(node_a.val);
+				current_a = node_a.next;
+			} else {
+				merged.add(node_b.val);
+				current_b = node_b.next;
+			}
+		}
+		
+		// 处理剩余的节点
+		while let Some(ptr_a) = current_a {
+			let node_a = unsafe { &*ptr_a.as_ptr() };
+			merged.add(node_a.val);
+			current_a = node_a.next;
+		}
+		
+		while let Some(ptr_b) = current_b {
+			let node_b = unsafe { &*ptr_b.as_ptr() };
+			merged.add(node_b.val);
+			current_b = node_b.next;
+		}
+		
+		merged
 	}
 }
 
@@ -104,6 +132,15 @@ where
     }
 }
 
+impl<T> Drop for LinkedList<T> {
+    fn drop(&mut self) {
+        while let Some(node_ptr) = self.start {
+            let node = unsafe { Box::from_raw(node_ptr.as_ptr()) };
+            self.start = node.next;
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::LinkedList;

exercises/easy/algorithm10.rs

@@ -29,20 +29,36 @@ impl Graph for UndirectedGraph {
         &self.adjacency_table
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
-        //TODO
+        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));
     }
 }
 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 {
-        //TODO
-		true
-    }
-    fn add_edge(&mut self, edge: (&str, &str, i32)) {
-        //TODO
+        if self.contains(node) {
+            return false;
+        }
+        self.adjacency_table_mutable().insert(node.to_string(), Vec::new());
+        true
     }
+    fn add_edge(&mut self, edge: (&str, &str, i32));
     fn contains(&self, node: &str) -> bool {
         self.adjacency_table().get(node).is_some()
     }

exercises/easy/algorithm11.rs

@@ -14,8 +14,16 @@
 use std::fmt::{self, Display, Formatter};
 
 pub fn find_missing_number(nums: Vec<i32>) -> i32 {
-    // TODO: Implement the logic to find the missing number
-    0 // Placeholder return value
+    let n = (nums.len() + 1) as i32; // 数组长度加1就是完整序列的长度
+    
+    // 计算从1到n的理论总和
+    let expected_sum = n * (n + 1) / 2;
+    
+    // 计算实际数组的总和
+    let actual_sum: i32 = nums.iter().sum();
+    
+    // 理论总和减去实际总和就是缺失的数字
+    expected_sum - actual_sum
 }
 
 #[cfg(test)]

exercises/easy/algorithm12.rs

@@ -12,8 +12,31 @@
 use std::fmt::{self, Display, Formatter};
 
 pub fn is_palindrome(s: String) -> bool {
-    // TODO: Implement the logic to check if the string is a palindrome
-    false // Placeholder return value
+    // 将字符串转换为小写并只保留字母字符
+    let chars: Vec<char> = s
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_alphabetic())
+        .collect();
+    
+    // 如果处理后的字符串为空，返回true
+    if chars.is_empty() {
+        return true;
+    }
+    
+    // 使用双指针从两端向中间比较
+    let mut left = 0;
+    let mut right = chars.len() - 1;
+    
+    while left < right {
+        if chars[left] != chars[right] {
+            return false;
+        }
+        left += 1;
+        right -= 1;
+    }
+    
+    true
 }
 
 #[cfg(test)]

exercises/easy/algorithm13.rs

@@ -14,8 +14,30 @@
 use std::fmt::{self, Display, Formatter};
 
 pub fn are_anagrams(s1: String, s2: String) -> bool {
-    // TODO: Implement the logic to check if two strings are anagrams
-    false // Placeholder return value
+    // 将字符串转换为小写并只保留字母字符
+    let mut chars1: Vec<char> = s1
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_alphabetic())
+        .collect();
+    
+    let mut chars2: Vec<char> = s2
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_alphabetic())
+        .collect();
+    
+    // 如果处理后的字符串长度不同，一定不是变位词
+    if chars1.len() != chars2.len() {
+        return false;
+    }
+    
+    // 对两个字符数组进行排序
+    chars1.sort_unstable();
+    chars2.sort_unstable();
+    
+    // 比较排序后的字符数组是否相同
+    chars1 == chars2
 }
 
 #[cfg(test)]

exercises/easy/algorithm14.rs

@@ -12,8 +12,29 @@
 use std::fmt::{self, Display, Formatter};
 
 pub fn find_duplicates(nums: Vec<i32>) -> Vec<i32> {
-    // TODO: Implement the logic to find all duplicates in the array
-    Vec::new() // Placeholder return value
+    let mut nums = nums; // 获取数组的可变引用
+    let mut result = Vec::new();
+    
+    // 使用数组元素的正负号来标记是否出现过
+    for i in 0..nums.len() {
+        // 获取当前数字的绝对值作为索引（减1是因为数组索引从0开始）
+        let index = nums[i].abs() as usize - 1;
+        
+        // 如果对应位置的数字已经是负数，说明这个数字之前出现过
+        if nums[index] < 0 {
+            // 避免重复添加相同的数字
+            if !result.contains(&(index as i32 + 1)) {
+                result.push(index as i32 + 1);
+            }
+        } else {
+            // 将对应位置的数字标记为负数，表示这个数字已经出现过
+            nums[index] = -nums[index];
+        }
+    }
+    
+    // 对结果进行排序，保证输出顺序一致
+    result.sort_unstable();
+    result
 }
 
 #[cfg(test)]

exercises/easy/algorithm15.rs

@@ -10,10 +10,31 @@
 */
 
 use std::fmt::{self, Display, Formatter};
+use std::collections::HashMap;
 
 pub fn longest_substring_without_repeating_chars(s: String) -> i32 {
-    // TODO: Implement the logic to find the longest substring without repeating characters
-    0 // Placeholder return value
+    let chars: Vec<char> = s.chars().collect();
+    let mut char_index = HashMap::new(); // 记录字符最后出现的位置
+    let mut max_length = 0;
+    let mut start = 0; // 滑动窗口的起始位置
+    
+    for (end, &ch) in chars.iter().enumerate() {
+        // 如果字符已经在当前窗口中出现过，更新窗口起始位置
+        if let Some(&prev_index) = char_index.get(&ch) {
+            // 只有当前窗口包含重复字符时才更新起始位置
+            if prev_index >= start {
+                start = prev_index + 1;
+            }
+        }
+        
+        // 更新字符最后出现的位置
+        char_index.insert(ch, end);
+        
+        // 更新最大长度
+        max_length = max_length.max(end - start + 1);
+    }
+    
+    max_length as i32
 }
 
 #[cfg(test)]

exercises/easy/algorithm16.rs

@@ -12,7 +12,52 @@
 use std::fmt::{self, Display, Formatter};
 
 pub fn rotate_matrix_90_degrees(matrix: &mut Vec<Vec<i32>>) {
-    // TODO: Implement the logic to rotate the matrix 90 degrees in place
+    let n = matrix.len();
+    
+    // 处理非方阵的情况：调整矩阵大小为最大边长的方阵
+    let max_dim = n.max(matrix[0].len());
+    
+    // 调整矩阵行数
+    while matrix.len() < max_dim {
+        matrix.push(vec![0; matrix[0].len()]);
+    }
+    
+    // 调整矩阵列数
+    for row in matrix.iter_mut() {
+        while row.len() < max_dim {
+            row.push(0);
+        }
+    }
+    
+    // 从外到内，一层一层旋转
+    for layer in 0..max_dim/2 {
+        let last = max_dim - 1 - layer;
+        
+        for i in layer..last {
+            // 保存左上角的值
+            let temp = matrix[layer][i];
+            
+            // 左边的值移到上边
+            matrix[layer][i] = matrix[last - (i - layer)][layer];
+            
+            // 下边的值移到左边
+            matrix[last - (i - layer)][layer] = matrix[last][last - (i - layer)];
+            
+            // 右边的值移到下边
+            matrix[last][last - (i - layer)] = matrix[i][last];
+            
+            // 上边的值（之前保存的）移到右边
+            matrix[i][last] = temp;
+        }
+    }
+    
+    // 如果原矩阵不是方阵，需要调整结果矩阵的大小
+    if n != matrix[0].len() {
+        // 调整行数
+        while matrix.len() > matrix[0].len() {
+            matrix.pop();
+        }
+    }
 }
 
 #[cfg(test)]

exercises/easy/algorithm17.rs

@@ -10,10 +10,24 @@
 */
 
 use std::fmt::{self, Display, Formatter};
+use std::collections::HashSet;
 
 pub fn intersection(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
-    // TODO: Implement the logic to find the intersection of two arrays
-    Vec::new() // Placeholder return value
+    // 将第一个数组转换为 HashSet，自动去重
+    let set1: HashSet<_> = nums1.into_iter().collect();
+    
+    // 将第二个数组转换为 HashSet，自动去重
+    let set2: HashSet<_> = nums2.into_iter().collect();
+    
+    // 计算两个集合的交集并收集到 Vec 中
+    let mut result: Vec<_> = set1.intersection(&set2)
+        .cloned()
+        .collect();
+    
+    // 对结果排序以保证输出顺序一致
+    result.sort_unstable();
+    
+    result
 }
 
 #[cfg(test)]

exercises/easy/algorithm18.rs

@@ -14,8 +14,33 @@
 use std::fmt::{self, Display, Formatter};
 
 pub fn merge_intervals(intervals: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
-    // TODO: Implement the logic to merge overlapping intervals
-    Vec::new() // Placeholder return value
+    if intervals.is_empty() {
+        return Vec::new();
+    }
+    
+    // 创建一个可变的区间副本并按起始点排序
+    let mut intervals = intervals;
+    intervals.sort_by_key(|interval| interval[0]);
+    
+    let mut result = Vec::new();
+    let mut current = intervals[0].clone();
+    
+    // 遍历所有区间进行合并
+    for interval in intervals.into_iter().skip(1) {
+        if interval[0] <= current[1] {
+            // 区间重叠，更新当前区间的结束点
+            current[1] = current[1].max(interval[1]);
+        } else {
+            // 区间不重叠，将当前区间加入结果，开始新的区间
+            result.push(current);
+            current = interval;
+        }
+    }
+    
+    // 添加最后一个区间
+    result.push(current);
+    
+    result
 }
 
 #[cfg(test)]