update

Author: ljs958

exercises/algorithm/algorithm1.rs

@@ -2,7 +2,6 @@
 	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;
@@ -70,14 +69,42 @@ 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 + Copy,
+    {
+        let mut res = LinkedList::new();
+        let mut a = list_a.start;
+        let mut b = list_b.start;
+
+        // 比较两个链表当前节点的值，较小的值追加到结果链表并推进对应指针
+        while a.is_some() && b.is_some() {
+            let a_ptr = a.unwrap();
+            let b_ptr = b.unwrap();
+            let a_val = unsafe { (*a_ptr.as_ptr()).val };
+            let b_val = unsafe { (*b_ptr.as_ptr()).val };
+            if a_val <= b_val {
+                res.add(a_val);
+                a = unsafe { (*a_ptr.as_ptr()).next };
+            } else {
+                res.add(b_val);
+                b = unsafe { (*b_ptr.as_ptr()).next };
+            }
         }
-	}
+
+        // 追加剩余部分
+        while let Some(a_ptr) = a {
+            let a_val = unsafe { (*a_ptr.as_ptr()).val };
+            res.add(a_val);
+            a = unsafe { (*a_ptr.as_ptr()).next };
+        }
+        while let Some(b_ptr) = b {
+            let b_val = unsafe { (*b_ptr.as_ptr()).val };
+            res.add(b_val);
+            b = unsafe { (*b_ptr.as_ptr()).next };
+        }
+
+        res
+    }
 }
 
 impl<T> Display for LinkedList<T>

exercises/algorithm/algorithm10.rs

@@ -2,7 +2,6 @@
 	graph
 	This problem requires you to implement a basic graph functio
 */
-// I AM NOT DONE
 
 use std::collections::{HashMap, HashSet};
 use std::fmt;
@@ -30,6 +29,21 @@ impl Graph for UndirectedGraph {
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
         //TODO
+        let (from, to, weight) = edge;
+        // add nodes if missing
+        self.adjacency_table
+            .entry(from.to_string())
+            .or_insert_with(Vec::new);
+        self.adjacency_table
+            .entry(to.to_string())
+            .or_insert_with(Vec::new);
+        // push both directions (undirected)
+        if let Some(neighs) = self.adjacency_table.get_mut(from) {
+            neighs.push((to.to_string(), weight));
+        }
+        if let Some(neighs) = self.adjacency_table.get_mut(to) {
+            neighs.push((from.to_string(), weight));
+        }
     }
 }
 pub trait Graph {
@@ -38,10 +52,17 @@ pub trait Graph {
     fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>>;
     fn add_node(&mut self, node: &str) -> bool {
         //TODO
-		true
+		if self.adjacency_table().get(node).is_some() {
+            false
+        } else {
+            self.adjacency_table_mutable()
+                .insert(node.to_string(), Vec::new());
+            true
+        }
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
         //TODO
+        let _ = edge;
     }
     fn contains(&self, node: &str) -> bool {
         self.adjacency_table().get(node).is_some()

exercises/algorithm/algorithm2.rs

@@ -2,7 +2,6 @@
 	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;
@@ -73,7 +72,19 @@ impl<T> LinkedList<T> {
         }
     }
 	pub fn reverse(&mut self){
-		// TODO
+		let mut current = self.start;
+        let mut prev = None;
+        self.end = self.start;
+        while let Some(node_ptr) = current {
+            let next = unsafe { (*node_ptr.as_ptr()).next };
+            unsafe {
+                (*node_ptr.as_ptr()).next = prev;
+                (*node_ptr.as_ptr()).prev = next;
+            }
+            prev = current;
+            current = next;
+        }
+        self.start = prev;
 	}
 }
 

exercises/algorithm/algorithm3.rs

@@ -3,11 +3,21 @@
 	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]){
-	//TODO
-}
+fn sort<T>(array: &mut [T])
+	where 
+        T: Ord + Copy,
+    {
+        let len = array.len();
+        for i in 0..len {
+            for j in 0..len -i - 1{
+                if array[j] > array[j+1]{
+                    array.swap(j,j+1);
+                }
+            }
+        }
+    }
+
 #[cfg(test)]
 mod tests {
     use super::*;

exercises/algorithm/algorithm4.rs

@@ -3,7 +3,6 @@
 	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;
 
@@ -51,12 +50,28 @@ where
     // Insert a value into the BST
     fn insert(&mut self, value: T) {
         //TODO
+        match self.root {
+            None => {
+                self.root = Some(Box::new(TreeNode::new(value)));
+            }
+            Some(ref mut node) => {
+                node.insert(value);
+            }
+        }
     }
 
     // Search for a value in the BST
     fn search(&self, value: T) -> bool {
         //TODO
-        true
+        let mut cur = &self.root;
+        while let Some(ref node) = cur {
+            match value.cmp(&node.value) {
+                Ordering::Equal => return true,
+                Ordering::Less => cur = &node.left,
+                Ordering::Greater => cur = &node.right,
+            }
+        }
+        false
     }
 }
 
@@ -67,6 +82,24 @@ where
     // Insert a node into the tree
     fn insert(&mut self, value: T) {
         //TODO
+        match value.cmp(&self.value) {
+            Ordering::Less => {
+                if let Some(ref mut left) = self.left {
+                    left.insert(value);
+                } else {
+                    self.left = Some(Box::new(TreeNode::new(value)));
+                }
+            }
+            Ordering::Greater => {
+                if let Some(ref mut right) = self.right {
+                    right.insert(value);
+                } else {
+                    self.right = Some(Box::new(TreeNode::new(value)));
+                }
+            }
+            Ordering::Equal => {
+            }
+        }
     }
 }
 

exercises/algorithm/algorithm5.rs

@@ -3,7 +3,6 @@
 	This problem requires you to implement a basic BFS algorithm
 */
 
-//I AM NOT DONE
 use std::collections::VecDeque;
 
 // Define a graph
@@ -29,8 +28,28 @@ impl Graph {
     fn bfs_with_return(&self, start: usize) -> Vec<usize> {
 
 		//TODO
+        let n = self.adj.len();
+        let mut visit_order = Vec::new();
+        if start >= n {
+            return visit_order;
+        }
+
+        let mut visited = vec![false; n];
+        let mut queue: VecDeque<usize> = VecDeque::new();
+
+        visited[start] = true;
+        queue.push_back(start);
+
+        while let Some(u) = queue.pop_front() {
+            visit_order.push(u);
+            for &v in &self.adj[u] {
+                if v < n && !visited[v] {
+                    visited[v] = true;       // 标记已访问以避免重复入队
+                    queue.push_back(v);
+                }
+            }
+        }
 
-        let mut visit_order = vec![];
         visit_order
     }
 }

exercises/algorithm/algorithm6.rs

@@ -3,7 +3,6 @@
 	This problem requires you to implement a basic DFS traversal
 */
 
-// I AM NOT DONE
 use std::collections::HashSet;
 
 struct Graph {
@@ -24,6 +23,16 @@ impl Graph {
 
     fn dfs_util(&self, v: usize, visited: &mut HashSet<usize>, visit_order: &mut Vec<usize>) {
         //TODO
+        if !visited.insert(v) {
+            return;
+        }
+        visit_order.push(v);
+
+        for &nei in &self.adj[v] {
+            if !visited.contains(&nei) {
+                self.dfs_util(nei, visited, visit_order);
+            }
+        }
     }
 
     // Perform a depth-first search on the graph, return the order of visited nodes

exercises/algorithm/algorithm7.rs

@@ -3,7 +3,6 @@
 	This question requires you to use a stack to achieve a bracket match
 */
 
-// I AM NOT DONE
 #[derive(Debug)]
 struct Stack<T> {
 	size: usize,
@@ -32,7 +31,12 @@ impl<T> Stack<T> {
 	}
 	fn pop(&mut self) -> Option<T> {
 		// TODO
-		None
+		if self.size == 0 {
+            None
+        } else {
+            self.size -= 1;
+            self.data.pop()
+        }
 	}
 	fn peek(&self) -> Option<&T> {
 		if 0 == self.size {
@@ -102,7 +106,17 @@ impl<'a, T> Iterator for IterMut<'a, T> {
 fn bracket_match(bracket: &str) -> bool
 {
 	//TODO
-	true
+	let mut st: Stack<char> = Stack::new();
+    for ch in bracket.chars() {
+        match ch {
+            '(' | '[' | '{' => st.push(ch),
+            ')' => if st.pop() != Some('(') { return false },
+            ']' => if st.pop() != Some('[') { return false },
+            '}' => if st.pop() != Some('{') { return false },
+            _ => {}
+        }
+    }
+    st.is_empty()
 }
 
 #[cfg(test)]

exercises/algorithm/algorithm8.rs

@@ -2,7 +2,6 @@
 	queue
 	This question requires you to use queues to implement the functionality of the stac
 */
-// I AM NOT DONE
 
 #[derive(Debug)]
 pub struct Queue<T> {
@@ -68,14 +67,20 @@ impl<T> myStack<T> {
     }
     pub fn push(&mut self, elem: T) {
         //TODO
+        self.q2.enqueue(elem);
+        while !self.q1.is_empty() {
+            let v = self.q1.dequeue().unwrap();
+            self.q2.enqueue(v);
+        }
+        std::mem::swap(&mut self.q1, &mut self.q2);
     }
     pub fn pop(&mut self) -> Result<T, &str> {
         //TODO
-		Err("Stack is empty")
+		self.q1.dequeue().map_err(|_| "Stack is empty")
     }
     pub fn is_empty(&self) -> bool {
 		//TODO
-        true
+        self.q1.is_empty()
     }
 }