update

Author: Leakbox258

README.md

@@ -19,7 +19,7 @@
 
   1. 再按照下面的环境安装提示在VSCode的 `console` 中安装配置开发环境：rustc等工具。
 
-  3. 然后就可以基于在线VSCode进行测试 (执行命令 `rustlings watch` ），编辑代码的循环实验过程了。
+  3. 然后就可以基于在线VSCode进行测试 (执行命令 `rustlings watch` )，编辑代码的循环实验过程了。
 
 3. 上述步骤有任何问题都可以找助教。
 

exercises/algorithm/algorithm1.rs

@@ -1,8 +1,7 @@
 /*
-	single linked list merge
-	This problem requires you to merge two ordered singly linked lists into one ordered singly linked list
+    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;
@@ -16,12 +15,30 @@ struct Node<T> {
 
 impl<T> Node<T> {
     fn new(t: T) -> Node<T> {
-        Node {
-            val: t,
-            next: None,
-        }
+        Node { val: t, next: None }
+    }
+}
+
+trait UnSafeRead {
+    type ValType;
+    type NextType;
+    fn get_val(&self) -> Self::ValType;
+    fn get_next(&self) -> Option<Self::NextType>;
+}
+
+impl<T: Copy> UnSafeRead for NonNull<Node<T>> {
+    type ValType = T;
+    type NextType = NonNull<Node<T>>;
+
+    fn get_val(&self) -> Self::ValType {
+        unsafe { (*self.as_ptr()).val }
+    }
+
+    fn get_next(&self) -> Option<Self::NextType> {
+        unsafe { (*self.as_ptr()).next }
     }
 }
+
 #[derive(Debug)]
 struct LinkedList<T> {
     length: u32,
@@ -56,28 +73,66 @@ impl<T> LinkedList<T> {
         self.length += 1;
     }
 
-    pub fn get(&mut self, index: i32) -> Option<&T> {
-        self.get_ith_node(self.start, index)
+    pub fn get_val(&mut self, index: i32) -> Option<&T> {
+        self.get_ith_val(self.start, index)
     }
 
-    fn get_ith_node(&mut self, node: Option<NonNull<Node<T>>>, index: i32) -> Option<&T> {
+    fn get_ith_val(&mut self, node: Option<NonNull<Node<T>>>, index: i32) -> Option<&T> {
         match node {
             None => None,
             Some(next_ptr) => match index {
                 0 => Some(unsafe { &(*next_ptr.as_ptr()).val }),
+                _ => self.get_ith_val(unsafe { (*next_ptr.as_ptr()).next }, index - 1),
+            },
+        }
+    }
+    fn get_ith_node(
+        &mut self,
+        node: Option<NonNull<Node<T>>>,
+        index: i32,
+    ) -> Option<NonNull<Node<T>>> {
+        match node {
+            None => None,
+            Some(next_ptr) => match index {
+                0 => Some(next_ptr),
                 _ => self.get_ith_node(unsafe { (*next_ptr.as_ptr()).next }, index - 1),
             },
         }
     }
-	pub fn merge(list_a:LinkedList<T>,list_b:LinkedList<T>) -> Self
-	{
-		//TODO
-		Self {
-            length: 0,
-            start: None,
-            end: None,
+
+    pub fn merge(mut list_a: LinkedList<T>, mut list_b: LinkedList<T>) -> Self
+    where
+        T: PartialOrd + Copy,
+    {
+        let mut list_c = Self::new();
+        let node_a = list_a.start;
+        let node_b = list_b.start;
+
+        let mut node_a = list_a.get_ith_node(node_a, 0);
+        let mut node_b = list_b.get_ith_node(node_b, 0);
+
+        while let (Some(a_node), Some(b_node)) = (node_a.as_ref(), node_b.as_ref()) {
+            if a_node.get_val() > b_node.get_val() {
+                list_c.add(b_node.get_val());
+                node_b = list_b.get_ith_node(node_b, 1);
+            } else {
+                list_c.add(a_node.get_val());
+                node_a = list_a.get_ith_node(node_a, 1);
+            }
+        }
+
+        while let Some(a_node) = node_a.as_ref() {
+            list_c.add(a_node.get_val());
+            node_a = list_a.get_ith_node(node_a, 1);
+        }
+
+        while let Some(b_node) = node_b.as_ref() {
+            list_c.add(b_node.get_val());
+            node_b = list_b.get_ith_node(node_b, 1);
         }
-	}
+
+        list_c
+    }
 }
 
 impl<T> Display for LinkedList<T>
@@ -130,44 +185,44 @@ mod tests {
 
     #[test]
     fn test_merge_linked_list_1() {
-		let mut list_a = LinkedList::<i32>::new();
-		let mut list_b = LinkedList::<i32>::new();
-		let vec_a = vec![1,3,5,7];
-		let vec_b = vec![2,4,6,8];
-		let target_vec = vec![1,2,3,4,5,6,7,8];
-		
-		for i in 0..vec_a.len(){
-			list_a.add(vec_a[i]);
-		}
-		for i in 0..vec_b.len(){
-			list_b.add(vec_b[i]);
-		}
-		println!("list a {} list b {}", list_a,list_b);
-		let mut list_c = LinkedList::<i32>::merge(list_a,list_b);
-		println!("merged List is {}", list_c);
-		for i in 0..target_vec.len(){
-			assert_eq!(target_vec[i],*list_c.get(i as i32).unwrap());
-		}
-	}
-	#[test]
-	fn test_merge_linked_list_2() {
-		let mut list_a = LinkedList::<i32>::new();
-		let mut list_b = LinkedList::<i32>::new();
-		let vec_a = vec![11,33,44,88,89,90,100];
-		let vec_b = vec![1,22,30,45];
-		let target_vec = vec![1,11,22,30,33,44,45,88,89,90,100];
-
-		for i in 0..vec_a.len(){
-			list_a.add(vec_a[i]);
-		}
-		for i in 0..vec_b.len(){
-			list_b.add(vec_b[i]);
-		}
-		println!("list a {} list b {}", list_a,list_b);
-		let mut list_c = LinkedList::<i32>::merge(list_a,list_b);
-		println!("merged List is {}", list_c);
-		for i in 0..target_vec.len(){
-			assert_eq!(target_vec[i],*list_c.get(i as i32).unwrap());
-		}
-	}
-}
+        let mut list_a = LinkedList::<i32>::new();
+        let mut list_b = LinkedList::<i32>::new();
+        let vec_a = vec![1, 3, 5, 7];
+        let vec_b = vec![2, 4, 6, 8];
+        let target_vec = vec![1, 2, 3, 4, 5, 6, 7, 8];
+
+        for i in 0..vec_a.len() {
+            list_a.add(vec_a[i]);
+        }
+        for i in 0..vec_b.len() {
+            list_b.add(vec_b[i]);
+        }
+        println!("list a {} list b {}", list_a, list_b);
+        let mut list_c = LinkedList::<i32>::merge(list_a, list_b);
+        println!("merged List is {}", list_c);
+        for i in 0..target_vec.len() {
+            assert_eq!(target_vec[i], *list_c.get_val(i as i32).unwrap());
+        }
+    }
+    #[test]
+    fn test_merge_linked_list_2() {
+        let mut list_a = LinkedList::<i32>::new();
+        let mut list_b = LinkedList::<i32>::new();
+        let vec_a = vec![11, 33, 44, 88, 89, 90, 100];
+        let vec_b = vec![1, 22, 30, 45];
+        let target_vec = vec![1, 11, 22, 30, 33, 44, 45, 88, 89, 90, 100];
+
+        for i in 0..vec_a.len() {
+            list_a.add(vec_a[i]);
+        }
+        for i in 0..vec_b.len() {
+            list_b.add(vec_b[i]);
+        }
+        println!("list a {} list b {}", list_a, list_b);
+        let mut list_c = LinkedList::<i32>::merge(list_a, list_b);
+        println!("merged List is {}", list_c);
+        for i in 0..target_vec.len() {
+            assert_eq!(target_vec[i], *list_c.get_val(i as i32).unwrap());
+        }
+    }
+}

exercises/algorithm/algorithm10.rs

@@ -1,8 +1,7 @@
 /*
-	graph
-	This problem requires you to implement a basic graph functio
+    graph
+    This problem requires you to implement a basic graph functio
 */
-// I AM NOT DONE
 
 use std::collections::{HashMap, HashSet};
 use std::fmt;
@@ -29,19 +28,57 @@ impl Graph for UndirectedGraph {
         &self.adjacency_table
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
-        //TODO
+        let from_node = edge.0.to_string();
+        let to_node = edge.1.to_string();
+        let value = edge.2;
+
+        match self.adjacency_table_mutable().get_mut(&from_node) {
+            Some(v) => v.push((to_node.clone(), value.clone())),
+            None => {
+                self.add_node(edge.0);
+                self.adjacency_table_mutable()
+                    .get_mut(&from_node)
+                    .unwrap()
+                    .push((to_node.clone(), value.clone()));
+            }
+        }
+
+        match self.adjacency_table_mutable().get_mut(&to_node) {
+            Some(v) => v.push((from_node, value)),
+            None => {
+                self.add_node(edge.1);
+                self.adjacency_table_mutable()
+                    .get_mut(&to_node)
+                    .unwrap()
+                    .push((from_node, value));
+            }
+        }
     }
 }
 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
+        self.adjacency_table_mutable()
+            .insert(node.to_string(), vec![])
+            .is_none()
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
-        //TODO
+        let from_node = edge.0.to_string();
+        let to_node = edge.1.to_string();
+        let value = edge.2;
+
+        match self.adjacency_table_mutable().get_mut(&from_node) {
+            Some(v) => v.push((to_node, value)),
+            None => {
+                self.add_node(edge.0);
+                self.adjacency_table_mutable()
+                    .get_mut(&from_node)
+                    .unwrap()
+                    .push((to_node, value));
+            }
+        }
     }
     fn contains(&self, node: &str) -> bool {
         self.adjacency_table().get(node).is_some()
@@ -81,4 +118,4 @@ mod test_undirected_graph {
             assert_eq!(graph.edges().contains(edge), true);
         }
     }
-}
+}