Skip to content

Update #4

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Update #4

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
170 changes: 112 additions & 58 deletions exercises/algorithm/algorithm1.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
/*
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 +16,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 All @@ -29,13 +26,13 @@ struct LinkedList<T> {
end: Option<NonNull<Node<T>>>,
}

impl<T> Default for LinkedList<T> {
impl<T: Ord> Default for LinkedList<T> {
fn default() -> Self {
Self::new()
}
}

impl<T> LinkedList<T> {
impl<T: Ord> LinkedList<T> {
pub fn new() -> Self {
Self {
length: 0,
Expand Down Expand Up @@ -69,15 +66,72 @@ 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(list_a: LinkedList<T>, list_b: LinkedList<T>) -> Self {
//TODO
let mut ret = LinkedList::new();

let mut a_node = list_a.start;
let mut b_node = list_b.start;
ret.length = list_a.length + list_b.length;
let mut stop = false;
let mut first = true;

while !stop {
match (a_node, b_node) {
(Some(a_ptr), Some(b_ptr)) => {
let a_val = unsafe { &(*a_ptr.as_ptr()).val };
let b_val = unsafe { &(*b_ptr.as_ptr()).val };
if a_val <= b_val {
if first {
ret.start = a_node;
ret.end = a_node;
first = false;
} else {
unsafe { (*ret.end.unwrap().as_ptr()).next = a_node };
ret.end = a_node;
}
a_node = unsafe { (*a_node.unwrap().as_ptr()).next };
} else {
if first {
ret.start = b_node;
ret.end = b_node;
first = false;
} else {
unsafe { (*ret.end.unwrap().as_ptr()).next = b_node };
ret.end = b_node;
}
b_node = unsafe { (*b_node.unwrap().as_ptr()).next };
}
}
(None, None) => {
stop = true;
}
(Some(a_ptr), None) => {
if first {
ret.start = a_node;
ret.end = list_a.end;
first = false;
} else {
unsafe { (*ret.end.unwrap().as_ptr()).next = a_node };
ret.end = list_a.end;
}
stop = true;
}
(None, Some(b_ptr)) => {
if first {
ret.start = b_node;
ret.end = list_b.end;
first = false;
} else {
unsafe { (*ret.end.unwrap().as_ptr()).next = b_node };
ret.end = list_b.end;
}
stop = true;
}
}
}
}
ret
}
}

impl<T> Display for LinkedList<T>
Expand Down Expand Up @@ -130,44 +184,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());
}
}
}
46 changes: 41 additions & 5 deletions exercises/algorithm/algorithm10.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
/*
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 Down Expand Up @@ -30,6 +30,36 @@ impl Graph for UndirectedGraph {
}
fn add_edge(&mut self, edge: (&str, &str, i32)) {
//TODO
let table = self.adjacency_table_mutable();
let (l, r, val) = edge;
if let Some(ref mut adj) = table.get_mut(l) {
let mut exist = false;
for (ref mut s, ref mut v) in adj.iter_mut() {
if s == r {
*v = val;
exist = true;
}
}
if !exist {
adj.push((String::from(r), val));
}
} else {
table.insert(String::from(l), vec![(String::from(r), val)]);
}
if let Some(ref mut adj) = table.get_mut(r) {
let mut exist = false;
for (ref mut s, ref mut v) in adj.iter_mut() {
if s == l {
*v = val;
exist = true;
}
}
if !exist {
adj.push((String::from(l), val));
}
} else {
table.insert(String::from(r), vec![(String::from(l), val)]);
}
}
}
pub trait Graph {
Expand All @@ -38,7 +68,13 @@ pub trait Graph {
fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>>;
fn add_node(&mut self, node: &str) -> bool {
//TODO
true

if self.contains(node) {
return false;
}
let mut table = self.adjacency_table_mutable();
table.insert(String::from(node), Vec::new());
true
}
fn add_edge(&mut self, edge: (&str, &str, i32)) {
//TODO
Expand Down Expand Up @@ -81,4 +117,4 @@ mod test_undirected_graph {
assert_eq!(graph.edges().contains(edge), true);
}
}
}
}
87 changes: 52 additions & 35 deletions exercises/algorithm/algorithm2.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
/*
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 +72,26 @@ impl<T> LinkedList<T> {
},
}
}
pub fn reverse(&mut self){
// TODO
}
pub fn reverse(&mut self) {
// TODO
let mut current = self.start;
let mut before = None;
self.end = self.start;
while let Some(node_ptr) = current {
let next = unsafe { (*node_ptr.as_ptr()).next };
if next.is_some() {
unsafe { (*node_ptr.as_ptr()).next = before };
unsafe { (*node_ptr.as_ptr()).prev = next };
before = current;
current = next;
} else {
self.start = current;
unsafe { (*node_ptr.as_ptr()).next = before };
unsafe { (*node_ptr.as_ptr()).prev = next };
break;
}
}
}
}

impl<T> Display for LinkedList<T>
Expand Down Expand Up @@ -127,33 +144,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());
}
}
}
Loading