update

Author: 788994

exercises/algorithm/algorithm1.rs

@@ -2,7 +2,7 @@
 	single linked list merge
 	This problem requires you to merge two ordered singly linked lists into one ordered singly linked list
 */
-// I AM NOT DONE
+//
 
 use std::fmt::{self, Display, Formatter};
 use std::ptr::NonNull;
@@ -47,7 +47,7 @@ impl<T> LinkedList<T> {
     pub fn add(&mut self, obj: T) {
         let mut node = Box::new(Node::new(obj));
         node.next = None;
-        let node_ptr = Some(unsafe { NonNull::new_unchecked(Box::into_raw(node)) });
+        let node_ptr =  NonNull::new(Box::into_raw(node));
         match self.end {
             None => self.start = node_ptr,
             Some(end_ptr) => unsafe { (*end_ptr.as_ptr()).next = node_ptr },
@@ -70,13 +70,57 @@ impl<T> LinkedList<T> {
         }
     }
 	pub fn merge(list_a:LinkedList<T>,list_b:LinkedList<T>) -> Self
-	{
+
 		//TODO
-		Self {
-            length: 0,
-            start: None,
-            end: None,
-        }
+    where
+        T: Ord+Clone, // 要求 T 实现 Ord 特质，支持比较大小
+        {
+            let mut merged_list = LinkedList::new();
+            // 初始化两个指针，指向两个链表的头节点
+            let mut ptr_a = list_a.start;
+            let mut ptr_b = list_b.start;
+
+            // 双指针循环比较，直到其中一个链表遍历完毕
+            while let (Some(a), Some(b)) = (ptr_a, ptr_b) {
+                let a_node = unsafe { a.as_ref() };
+                let b_node = unsafe { b.as_ref() };
+
+                // 比较节点值，将较小的节点添加到新链表
+                if a_node.val <= b_node.val {
+                    // 取出 ptr_a 指向的节点，添加到新链表
+                    merged_list.add(a_node.val.clone()); // 注意：需要 T 实现 Clone（下方补充约束）
+                    // 移动 ptr_a 到下一个节点
+                    ptr_a = a_node.next;
+                } else {
+                    // 取出 ptr_b 指向的节点，添加到新链表
+                    merged_list.add(b_node.val.clone());
+                    // 移动 ptr_b 到下一个节点
+                    ptr_b = b_node.next;
+                }
+            }
+
+            // 处理 list_a 剩余的节点
+            while let Some(a) = ptr_a {
+                let a_node = unsafe { a.as_ref() };
+                merged_list.add(a_node.val.clone());
+                ptr_a = a_node.next;
+            }
+
+            // 处理 list_b 剩余的节点
+            while let Some(b) = ptr_b {
+                let b_node = unsafe { b.as_ref() };
+                merged_list.add(b_node.val.clone());
+                ptr_b = b_node.next;
+            }
+
+            merged_list
+
+
+		// Self {
+        //     length: 0,
+        //     start: None,
+        //     end: None,
+        // }
 	}
 }
 
@@ -104,6 +148,9 @@ where
     }
 }
 
+// 为了支持 val.clone()，需要为 LinkedList<T> 的方法补充 Clone 约束
+impl<T: Clone + Ord> LinkedList<T> {}
+
 #[cfg(test)]
 mod tests {
     use super::LinkedList;

exercises/algorithm/algorithm10.rs

@@ -2,7 +2,7 @@
 	graph
 	This problem requires you to implement a basic graph functio
 */
-// I AM NOT DONE
+// I AM   DONE
 
 use std::collections::{HashMap, HashSet};
 use std::fmt;
@@ -30,6 +30,22 @@ impl Graph for UndirectedGraph {
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
         //TODO
+        let (from, to, weight) = edge;
+        // 确保两个节点都存在（不存在则自动添加）
+        self.add_node(from);
+        self.add_node(to);
+
+        // 向 from 节点的邻接列表添加 to 节点和权重
+        self.adjacency_table
+            .get_mut(&from.to_string())
+            .unwrap() // 已通过 add_node 确保存在，unwrap 安全
+            .push((to.to_string(), weight));
+
+        // 向 to 节点的邻接列表添加 from 节点和权重（无向边双向性）
+        self.adjacency_table
+            .get_mut(&to.to_string())
+            .unwrap() // 已通过 add_node 确保存在，unwrap 安全
+            .push((from.to_string(), weight));
     }
 }
 pub trait Graph {
@@ -38,6 +54,10 @@ pub trait Graph {
     fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>>;
     fn add_node(&mut self, node: &str) -> bool {
         //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)) {

exercises/algorithm/algorithm2.rs

@@ -2,7 +2,7 @@
 	double linked list reverse
 	This problem requires you to reverse a doubly linked list
 */
-// I AM NOT DONE
+
 
 use std::fmt::{self, Display, Formatter};
 use std::ptr::NonNull;
@@ -50,7 +50,7 @@ impl<T> LinkedList<T> {
         let mut node = Box::new(Node::new(obj));
         node.next = None;
         node.prev = self.end;
-        let node_ptr = Some(unsafe { NonNull::new_unchecked(Box::into_raw(node)) });
+        let node_ptr = NonNull::new(Box::into_raw(node));
         match self.end {
             None => self.start = node_ptr,
             Some(end_ptr) => unsafe { (*end_ptr.as_ptr()).next = node_ptr },
@@ -74,6 +74,27 @@ impl<T> LinkedList<T> {
     }
 	pub fn reverse(&mut self){
 		// TODO
+        // 处理空链表或只有一个节点的情况，直接返回
+        if self.length <= 1 {
+            return;
+        }
+
+        // 临时指针，用于遍历链表
+        let mut current = self.start;
+        // 交换链表的头和尾
+        std::mem::swap(&mut self.start, &mut self.end);
+
+        // 遍历每个节点，交换 prev 和 next 指针
+        while let Some(mut cur_ptr) = current {
+            unsafe {
+                // 获取当前节点的可变引用
+                let cur_node = cur_ptr.as_mut();
+                // 交换当前节点的 prev 和 next
+                std::mem::swap(&mut cur_node.prev, &mut cur_node.next);
+                // 移动到下一个节点（注意：因为 prev/next 已交换，现在要走 prev 指针）
+                current = cur_node.prev;
+            }
+        }
 	}
 }
 

exercises/algorithm/algorithm3.rs

@@ -3,10 +3,38 @@
 	This problem requires you to implement a sorting algorithm
 	you can use bubble sorting, insertion sorting, heap sorting, etc.
 */
-// I AM NOT DONE
+//
 
-fn sort<T>(array: &mut [T]){
+fn sort<T:Ord>(array: &mut [T]){
 	//TODO
+    // 如果数组长度 <= 1，直接返回（已经有序）
+    if array.len() <= 1 {
+        return;
+    }
+
+    let mut swapped;
+    let mut n = array.len();
+
+    // 冒泡排序核心逻辑
+    loop {
+        swapped = false;
+        // 遍历未排序部分，比较相邻元素
+        for i in 1..n {
+            // 如果前一个元素大于后一个，交换位置
+            if array[i - 1] > array[i] {
+                array.swap(i - 1, i);
+                swapped = true;
+            }
+        }
+
+        // 每轮结束后，最后一个元素已排序，缩小遍历范围
+        n -= 1;
+
+        // 如果本轮没有交换，说明数组已完全有序，退出循环
+        if !swapped {
+            break;
+        }
+    }
 }
 #[cfg(test)]
 mod tests {

exercises/algorithm/algorithm4.rs

@@ -3,11 +3,10 @@
 	This problem requires you to implement a basic interface for a binary tree
 */
 
-//I AM NOT DONE
+
 use std::cmp::Ordering;
 use std::fmt::Debug;
 
-
 #[derive(Debug)]
 struct TreeNode<T>
 where
@@ -37,40 +36,70 @@ where
             right: None,
         }
     }
+
+    // 辅助方法：在当前节点的子树中插入值
+    fn insert(&mut self, value: T) {
+        match value.cmp(&self.value) {
+            // 插入值小于当前节点值 → 插入左子树
+            Ordering::Less => {
+                if let Some(ref mut left_node) = self.left {
+                    left_node.insert(value);
+                } else {
+                    self.left = Some(Box::new(TreeNode::new(value)));
+                }
+            }
+            // 插入值大于当前节点值 → 插入右子树
+            Ordering::Greater => {
+                if let Some(ref mut right_node) = self.right {
+                    right_node.insert(value);
+                } else {
+                    self.right = Some(Box::new(TreeNode::new(value)));
+                }
+            }
+            // 相等则不处理（BST 不存储重复值）
+            Ordering::Equal => (),
+        }
+    }
 }
 
 impl<T> BinarySearchTree<T>
 where
     T: Ord,
 {
-
     fn new() -> Self {
         BinarySearchTree { root: None }
     }
 
-    // Insert a value into the BST
+    // 插入值到 BST
     fn insert(&mut self, value: T) {
-        //TODO
+        if let Some(ref mut root_node) = self.root {
+            // 根节点存在，调用节点的 insert 方法
+            root_node.insert(value);
+        } else {
+            // 根节点为空，新建根节点
+            self.root = Some(Box::new(TreeNode::new(value)));
+        }
     }
 
-    // Search for a value in the BST
+    // 查找值是否存在于 BST 中
     fn search(&self, value: T) -> bool {
-        //TODO
-        true
-    }
-}
-
-impl<T> TreeNode<T>
-where
-    T: Ord,
-{
-    // Insert a node into the tree
-    fn insert(&mut self, value: T) {
-        //TODO
+        // 从根节点开始查找
+        let mut current = &self.root;
+        while let Some(ref node) = current {
+            match value.cmp(&node.value) {
+                // 找到匹配值 → 返回 true
+                Ordering::Equal => return true,
+                // 查找值更小 → 去左子树找
+                Ordering::Less => current = &node.left,
+                // 查找值更大 → 去右子树找
+                Ordering::Greater => current = &node.right,
+            }
+        }
+        // 遍历完所有节点未找到 → 返回 false
+        false
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

exercises/algorithm/algorithm5.rs

@@ -3,7 +3,7 @@
 	This problem requires you to implement a basic BFS algorithm
 */
 
-//I AM NOT DONE
+//
 use std::collections::VecDeque;
 
 // Define a graph
@@ -29,8 +29,37 @@ impl Graph {
     fn bfs_with_return(&self, start: usize) -> Vec<usize> {
 
 		//TODO
+        // 处理空图/起点越界的情况（测试用例中起点都是合法的，此处做防御性处理）
+        if start >= self.adj.len() {
+            return vec![];
+        }
+
+        // 1. 初始化访问标记数组：false 表示未访问，true 表示已访问
+        let mut visited = vec![false; self.adj.len()];
+        // 2. 初始化队列，用于存储待访问的节点
+        let mut queue = VecDeque::new();
+        // 3. 初始化访问顺序列表
 
         let mut visit_order = vec![];
+
+        // 将起点加入队列并标记为已访问
+        queue.push_back(start);
+        visited[start] = true;
+
+        // 4. 循环处理队列中的节点
+        while let Some(current) = queue.pop_front() {
+            // 将当前节点加入访问顺序
+            visit_order.push(current);
+
+            // 遍历当前节点的所有邻接节点
+            for &neighbor in &self.adj[current] {
+                // 若邻接节点未被访问，则标记并加入队列
+                if !visited[neighbor] {
+                    visited[neighbor] = true;
+                    queue.push_back(neighbor);
+                }
+            }
+        }
         visit_order
     }
 }