Skip to content

Commit

Permalink
complete
Browse files Browse the repository at this point in the history
  • Loading branch information
daoshi1593 committed Feb 3, 2025
1 parent c71c476 commit c41ffea
Show file tree
Hide file tree
Showing 85 changed files with 998 additions and 624 deletions.
3 changes: 2 additions & 1 deletion .vscode/extensions.json
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
{
"recommendations": [
"rust-lang.rust-analyzer"
]
],
"rust-analyzer.linkedProjects":["rust-rustlings-2024-autumn-daoshi1593/Cargo.toml"]
}
161 changes: 105 additions & 56 deletions exercises/algorithm/algorithm1.rs
Original file line number Diff line number Diff line change
@@ -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;
Expand All @@ -16,10 +15,7 @@ struct Node<T> {

impl<T> Node<T> {
fn new(t: T) -> Node<T> {
Node {
val: t,
next: None,
}
Node { val: t, next: None }
}
}
#[derive(Debug)]
Expand Down Expand Up @@ -69,15 +65,68 @@ impl<T> LinkedList<T> {
},
}
}
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,
// T: Clone,
// {
// let mut list_c = LinkedList::<T>::new();
// let mut node_a = list_a.start;
// let mut node_b = list_b.start;
// while node_a.is_some() && node_b.is_some() {
// let val_a = unsafe { (*node_a.unwrap().as_ptr()).val.clone() };
// let val_b = unsafe { (*node_b.unwrap().as_ptr()).val.clone() };
// if val_a < val_b {
// list_c.add(val_a.clone());
// node_a = unsafe { (*node_a.unwrap().as_ptr()).next };
// } else {
// list_c.add(val_b.clone());
// node_b = unsafe { (*node_b.unwrap().as_ptr()).next };
// }
// }
// while node_a.is_some() {
// let val_a = unsafe { (*node_a.unwrap().as_ptr()).val.clone() };
// list_c.add(val_a);
// node_a = unsafe { (*node_a.unwrap().as_ptr()).next };
// }
// while node_b.is_some() {
// let val_b = unsafe { (*node_b.unwrap().as_ptr()).val.clone() };
// list_c.add(val_b);
// node_b = unsafe { (*node_b.unwrap().as_ptr()).next };
// }
// list_c
// }
pub fn merge(mut list_a: LinkedList<T>, mut list_b: LinkedList<T>) -> Self
where
T: PartialOrd + Clone,
{
let mut list_c = LinkedList::new();
let mut node_a = list_a.start;
let mut node_b = list_b.start;

// 主合并循环
while let (Some(ptr_a), Some(ptr_b)) = (node_a, node_b) {
let (val_a, val_b) =
unsafe { (ptr_a.as_ref().val.clone(), ptr_b.as_ref().val.clone()) };

if val_a <= val_b {
list_c.add(val_a);
node_a = unsafe { ptr_a.as_ref().next };
} else {
list_c.add(val_b);
node_b = unsafe { ptr_b.as_ref().next };
}
}
}

// 处理剩余节点
let mut remaining = node_a.or(node_b);
while let Some(ptr) = remaining {
let val = unsafe { ptr.as_ref().val.clone() };
list_c.add(val);
remaining = unsafe { ptr.as_ref().next };
}
list_c
}
}

impl<T> Display for LinkedList<T>
Expand Down Expand Up @@ -130,44 +179,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(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());
}
}
}
27 changes: 20 additions & 7 deletions exercises/algorithm/algorithm10.rs
Original file line number Diff line number Diff line change
@@ -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;
Expand All @@ -29,16 +28,30 @@ impl Graph for UndirectedGraph {
&self.adjacency_table
}
fn add_edge(&mut self, edge: (&str, &str, i32)) {
//TODO
self.adjacency_table_mutable()
.entry(edge.0.to_string())
.or_insert_with(Vec::new)
.push((edge.1.to_string(), edge.2));

self.adjacency_table_mutable()
.entry(edge.1.to_string())
.or_insert_with(Vec::new)
.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
let table = self.adjacency_table_mutable();
if table.contains_key(node) {
return false;
} else {
self.adjacency_table_mutable()
.insert(node.to_string(), Vec::new());
}
true
}
fn add_edge(&mut self, edge: (&str, &str, i32)) {
//TODO
Expand Down Expand Up @@ -81,4 +94,4 @@ mod test_undirected_graph {
assert_eq!(graph.edges().contains(edge), true);
}
}
}
}
83 changes: 48 additions & 35 deletions exercises/algorithm/algorithm2.rs
Original file line number Diff line number Diff line change
@@ -1,8 +1,7 @@
/*
double linked list reverse
This problem requires you to reverse a doubly linked list
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;
Expand Down Expand Up @@ -72,9 +71,23 @@ impl<T> LinkedList<T> {
},
}
}
pub fn reverse(&mut self){
// TODO
}
pub fn reverse(&mut self) {
// TODO
let mut current = self.start;
let mut temp = None;
while let Some(mut node) = current {
unsafe {
temp = (*node.as_ptr()).prev;
(*node.as_ptr()).prev = (*node.as_ptr()).next;
(*node.as_ptr()).next = temp;
current = (*node.as_ptr()).prev;
}
}
if let Some(nd) = temp {
self.end = self.start;
self.start = unsafe { (*nd.as_ptr()).prev };
}
}
}

impl<T> Display for LinkedList<T>
Expand Down Expand Up @@ -127,33 +140,33 @@ mod tests {

#[test]
fn test_reverse_linked_list_1() {
let mut list = LinkedList::<i32>::new();
let original_vec = vec![2,3,5,11,9,7];
let reverse_vec = vec![7,9,11,5,3,2];
for i in 0..original_vec.len(){
list.add(original_vec[i]);
}
println!("Linked List is {}", list);
list.reverse();
println!("Reversed Linked List is {}", list);
for i in 0..original_vec.len(){
assert_eq!(reverse_vec[i],*list.get(i as i32).unwrap());
}
}
let mut list = LinkedList::<i32>::new();
let original_vec = vec![2, 3, 5, 11, 9, 7];
let reverse_vec = vec![7, 9, 11, 5, 3, 2];
for i in 0..original_vec.len() {
list.add(original_vec[i]);
}
println!("Linked List is {}", list);
list.reverse();
println!("Reversed Linked List is {}", list);
for i in 0..original_vec.len() {
assert_eq!(reverse_vec[i], *list.get(i as i32).unwrap());
}
}

#[test]
fn test_reverse_linked_list_2() {
let mut list = LinkedList::<i32>::new();
let original_vec = vec![34,56,78,25,90,10,19,34,21,45];
let reverse_vec = vec![45,21,34,19,10,90,25,78,56,34];
for i in 0..original_vec.len(){
list.add(original_vec[i]);
}
println!("Linked List is {}", list);
list.reverse();
println!("Reversed Linked List is {}", list);
for i in 0..original_vec.len(){
assert_eq!(reverse_vec[i],*list.get(i as i32).unwrap());
}
}
}
#[test]
fn test_reverse_linked_list_2() {
let mut list = LinkedList::<i32>::new();
let original_vec = vec![34, 56, 78, 25, 90, 10, 19, 34, 21, 45];
let reverse_vec = vec![45, 21, 34, 19, 10, 90, 25, 78, 56, 34];
for i in 0..original_vec.len() {
list.add(original_vec[i]);
}
println!("Linked List is {}", list);
list.reverse();
println!("Reversed Linked List is {}", list);
for i in 0..original_vec.len() {
assert_eq!(reverse_vec[i], *list.get(i as i32).unwrap());
}
}
}
26 changes: 17 additions & 9 deletions exercises/algorithm/algorithm3.rs
Original file line number Diff line number Diff line change
@@ -1,12 +1,20 @@
/*
sort
This problem requires you to implement a sorting algorithm
you can use bubble sorting, insertion sorting, heap sorting, etc.
sort
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: PartialOrd,
{
for i in 0..array.len() {
for j in 0..array.len() - 1 {
if array[j] > array[j + 1] {
array.swap(j, j + 1);
}
}
}
}
#[cfg(test)]
mod tests {
Expand All @@ -18,16 +26,16 @@ mod tests {
sort(&mut vec);
assert_eq!(vec, vec![19, 37, 46, 57, 64, 73, 75, 91]);
}
#[test]
#[test]
fn test_sort_2() {
let mut vec = vec![1];
sort(&mut vec);
assert_eq!(vec, vec![1]);
}
#[test]
#[test]
fn test_sort_3() {
let mut vec = vec![99, 88, 77, 66, 55, 44, 33, 22, 11];
sort(&mut vec);
assert_eq!(vec, vec![11, 22, 33, 44, 55, 66, 77, 88, 99]);
}
}
}
Loading

0 comments on commit c41ffea

Please sign in to comment.