update

Author: YoungCIoud

Cargo.lock

@@ -11,7 +11,7 @@ edition = "2021"
 [dependencies]
 argh = "0.1"
 indicatif = "0.16"
-console = "0.15"
+console = { version = "0.16", features = ["std"] }
 notify = "4.0"
 toml = "0.5"
 regex = "1.5"

Cargo.toml

@@ -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;
@@ -69,15 +68,39 @@ impl<T> LinkedList<T> {
             },
         }
     }
-	pub fn merge(list_a:LinkedList<T>,list_b:LinkedList<T>) -> Self
-	{
-		//TODO
-		Self {
-            length: 0,
-            start: None,
-            end: None,
+}
+
+impl<T: PartialOrd + Clone> LinkedList<T> {
+    pub fn merge(mut list_a: LinkedList<T>, mut list_b:LinkedList<T>) -> Self
+    {
+        let mut list = LinkedList::new();
+        let la = list_a.length;
+        let lb = list_b.length;
+        let mut pa = 0;
+        let mut pb = 0;
+        loop {
+            if pa < la && pb < lb {
+                let va = list_a.get(pa as i32).unwrap().clone();
+                let vb = list_b.get(pb as i32).unwrap().clone();
+                if va < vb {
+                    pa += 1;
+                    list.add(va);
+                } else {
+                    pb += 1;
+                    list.add(vb);
+                }
+            } else if pa < la {
+                list.add(list_a.get(pa as i32).unwrap().clone());
+                pa += 1;
+            } else if pb < lb {
+                list.add(list_b.get(pb as i32).unwrap().clone());
+                pb += 1;
+            } else {
+                break;
+            }
         }
-	}
+        list
+    }
 }
 
 impl<T> Display for LinkedList<T>

exercises/algorithm/algorithm1.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;
@@ -29,16 +28,27 @@ impl Graph for UndirectedGraph {
         &self.adjacency_table
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
-        //TODO
+        self.add_node(edge.0);
+        self.add_node(edge.1);
+        if let Some(adj) = self.adjacency_table_mutable().get_mut(edge.0) {
+            adj.push((edge.1.to_string(), edge.2));
+        }
+        if let Some(adj) = self.adjacency_table_mutable().get_mut(edge.1) {
+            adj.push((edge.0.to_string(), edge.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 {
-        //TODO
-		true
+        if self.contains(node) {
+            false
+        } else {
+            self.adjacency_table_mutable().insert(node.to_string(), Vec::new());
+            true
+        }
     }
     fn add_edge(&mut self, edge: (&str, &str, i32)) {
         //TODO

exercises/algorithm/algorithm10.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;
@@ -72,8 +71,40 @@ impl<T> LinkedList<T> {
             },
         }
     }
-	pub fn reverse(&mut self){
-		// TODO
+    pub fn reverse(&mut self){
+        if self.length <= 1 {
+            return;
+        }
+
+        let mut v = vec![None];
+        let mut cur = self.start;
+
+        loop {
+            match cur {
+                Some(node) => {
+                    v.push(Some(node));
+                    unsafe {
+                        cur = (*node.as_ptr()).next;
+                    }
+                },
+                None => {
+                    v.push(None);
+                    break;
+                },
+            }
+        }
+
+        for idx in 0..v.len() {
+            if let Some(node) = v[idx] {
+                unsafe {
+                    (*node.as_ptr()).next = v[idx - 1];
+                    (*node.as_ptr()).prev = v[idx + 1];
+                }
+            }
+        }
+
+        self.end = v[1];
+        self.start = v[v.len() - 2];
 	}
 }
 

exercises/algorithm/algorithm2.rs

@@ -3,10 +3,20 @@
 	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
+use std::mem::swap;
+
+fn sort<T: PartialOrd + Clone>(array: &mut [T]){
+	let n = array.len();
+    for i in 1..=n {
+        for j in 0..n - i {
+            if array[j] > array[j + 1] {
+                let tmp = array[j].clone();
+                array[j] = array[j + 1].clone();
+                array[j + 1] = tmp.clone();
+            }
+        }
+    }
 }
 #[cfg(test)]
 mod tests {

exercises/algorithm/algorithm3.rs

@@ -2,8 +2,6 @@
 	binary_search tree
 	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;
 
@@ -50,13 +48,32 @@ where
 
     // Insert a value into the BST
     fn insert(&mut self, value: T) {
-        //TODO
+        match &mut self.root {
+            Some(root) => root.insert(value),
+            None => self.root = Some(Box::new(TreeNode::new(value))),
+        }
     }
 
     // Search for a value in the BST
     fn search(&self, value: T) -> bool {
         //TODO
-        true
+        let mut cur = &self.root;
+
+        loop {
+            match cur {
+                Some(node) => {
+                    if node.value < value {
+                        cur = &node.left;
+                    } else if node.value > value {
+                        cur = &node.right;
+                    } else {
+                        return true;
+                    }
+                },
+                None => break,
+            }
+        }
+        false
     }
 }
 
@@ -66,7 +83,17 @@ where
 {
     // Insert a node into the tree
     fn insert(&mut self, value: T) {
-        //TODO
+        if self.value < value {
+            match &mut self.left {
+                Some(node) => node.insert(value),
+                None => self.left = Some(Box::new(TreeNode::new(value))),
+            }
+        } else if self.value > value {
+            match &mut self.right {
+                Some(node) => node.insert(value),
+                None => self.right = Some(Box::new(TreeNode::new(value))),
+            }
+        }
     }
 }
 

exercises/algorithm/algorithm4.rs

@@ -2,8 +2,6 @@
 	bfs
 	This problem requires you to implement a basic BFS algorithm
 */
-
-//I AM NOT DONE
 use std::collections::VecDeque;
 
 // Define a graph
@@ -27,10 +25,24 @@ impl Graph {
 
     // Perform a breadth-first search on the graph, return the order of visited nodes
     fn bfs_with_return(&self, start: usize) -> Vec<usize> {
-        
-		//TODO
-
         let mut visit_order = vec![];
+        let mut vis = vec![false; self.adj.len()];
+
+        let mut q = VecDeque::new();
+        q.push_back(start);
+        vis[start] = true;
+
+        while !q.is_empty() {
+            let cur = q.pop_front().unwrap();
+            visit_order.push(cur);
+            for to in &self.adj[cur] {
+                if !vis[*to] {
+                    vis[*to] = true;
+                    q.push_back(*to);
+                }
+            }
+        }
+        
         visit_order
     }
 }

exercises/algorithm/algorithm5.rs

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

exercises/algorithm/algorithm6.rs

@@ -2,8 +2,6 @@
 	stack
 	This question requires you to use a stack to achieve a bracket match
 */
-
-// I AM NOT DONE
 #[derive(Debug)]
 struct Stack<T> {
 	size: usize,
@@ -31,8 +29,12 @@ impl<T> Stack<T> {
 		self.size += 1;
 	}
 	fn pop(&mut self) -> Option<T> {
-		// TODO
-		None
+		if self.size > 0 {
+			self.size -= 1;
+			self.data.pop()
+		} else {
+			None
+		}
 	}
 	fn peek(&self) -> Option<&T> {
 		if 0 == self.size {
@@ -101,8 +103,37 @@ impl<'a, T> Iterator for IterMut<'a, T> {
 
 fn bracket_match(bracket: &str) -> bool
 {
-	//TODO
-	true
+	let mut stk = Stack::new();
+	let mut bracket = bracket.chars();
+
+	while let Some(ch) = bracket.next() {
+		match ch {
+			'(' => stk.push('('),
+			'[' => stk.push('['),
+			'{' => stk.push('{'),
+			')' => {
+				match stk.pop() {
+					Some(ch) if ch == '(' => continue,
+					_ => return false,
+				}
+			},
+			']' => {
+				match stk.pop() {
+					Some(ch) if ch == '[' => continue,
+					_ => return false,
+				}
+			},
+			'}' => {
+				match stk.pop() {
+					Some(ch) if ch == '{' => continue,
+					_ => return false,
+				}
+			},
+			_ => continue,
+		}
+	}
+
+	stk.is_empty()
 }
 
 #[cfg(test)]