added fn to get node by index of linked list

src/data_structures.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-// Define a struct to represent the adjacency list with weighted edges
 pub struct WeightedAdjacencyList<T, W> {
     vertices: HashMap<T, HashMap<T, W>>,
 }
@@ -175,99 +174,98 @@ impl<T: PartialOrd> MinHeap<T> {
     }
 }
 pub struct Queue<T> {
-  queue: Vec<T>,
+    queue: Vec<T>,
 }
 
 impl<T> Queue<T> {
-  pub fn new() -> Self {
+    pub fn new() -> Self {
-    Queue { queue: Vec::new() }
+        Queue { queue: Vec::new() }
-  }
+    }
-
+    pub fn length(&self) -> usize {
-  pub fn length(&self) -> usize {
+        self.queue.len()
-    self.queue.len()
+    }
-  }
+    pub fn enqueue(&mut self, item: T) {
-
+        self.queue.push(item)
-  pub fn enqueue(&mut self, item: T) {
+    }
-    self.queue.push(item)
+    pub fn dequeue(&mut self) -> T {
-  }
+        self.queue.remove(0)
-
+    }
-  pub fn dequeue(&mut self) -> T {
+    pub fn is_empty(&self) -> bool {
-    self.queue.remove(0)
+        self.queue.is_empty()
-  }
+    }
-  pub fn is_empty(&self) -> bool {
+    pub fn peek(&self) -> Option<&T> {
-    self.queue.is_empty()
+        self.queue.first()
-  }
+    }
-
-  pub fn peek(&self) -> Option<&T> {
-    self.queue.first()
-  }
 }
 
 pub struct Stack<T> {
-  stack: Vec<T>,
+    stack: Vec<T>,
 }
 
 impl<T> Stack<T> {
-  pub fn new() -> Self {
+    pub fn new() -> Self {
-    Stack { stack: Vec::new() }
+        Stack { stack: Vec::new() }
-  }
+    }
-
+    pub fn length(&self) -> usize {
-  pub fn length(&self) -> usize {
+        self.stack.len()
-    self.stack.len()
+    }
-  }
+    pub fn pop(&mut self) -> Option<T> {
-
+        self.stack.pop()
-  pub fn pop(&mut self) -> Option<T> {
+    }
-    self.stack.pop()
+    pub fn push(&mut self, item: T) {
-  }
+        self.stack.push(item)
-
+    }
-  pub fn push(&mut self, item: T) {
+    pub fn is_empty(&self) -> bool {
-    self.stack.push(item)
+        self.stack.is_empty()
-  }
+    }
-
+    pub fn peek(&self) -> Option<&T> {
-  pub fn is_empty(&self) -> bool {
+        self.stack.last()
-    self.stack.is_empty()
+    }
-  }
-
-  pub fn peek(&self) -> Option<&T> {
-    self.stack.last()
-  }
 }
 
-use std::mem;
 
 struct Node<T> {
-  value: T,
+    value: T,
-  next: Option<Box<Node<T>>>,
+    prev: Option<Box<Node<T>>>,
+    next: Option<Box<Node<T>>>,
 }
 
 type Link<T> = Option<Box<Node<T>>>;
 
 pub struct List<T> {
-  head: Link<T>,
+    head: Link<T>,
+    tail: Link<T>
 }
 
 impl<T> List<T> {
-  pub fn new() -> Self {
+    pub fn new() -> Self {
-    List { head: None }
+        List { head: None, tail: None }
-  }
+    }
+    // Access node by index
+    pub fn get_node(&self, index: usize) -> Option<&Node<T>> {
+        let mut current_node = self.head.as_ref().map(|boxed_node| &**boxed_node);
+        let mut current_index = 0;
 
-  pub fn push(&mut self, item: T) {
+        while let Some(node) = current_node {
-    let next_node = Box::new(Node {
+            if current_index == index {
-      value: item,
+                return Some(node);
-      next: self.head.take(),
+            }
-    });
+            current_node = node.next.as_ref().map(|boxed_node| &**boxed_node);
+            current_index += 1;
+        }
 
-    self.head = Some(next_node)
+        None
-  }
+    }
-
+    pub fn insert_before(insertion_node:Node<T>,node:Node<T>) -> Self {
-  pub fn pop(&mut self) -> Option<T> {
+        //TODO: Implement Insert Before
-    self.head.take().map(|node| {
+        List{head:None,tail:None}
-      self.head = node.next;
+    }
-      node.value
+    pub fn insert_after(insertion_node:Node<T>,node:Node<T>) -> Self {
-    })
+        //TODO: Implement Insert After
-  }
+        List{head:None,tail:None}
-
+    }
-  pub fn peek(&self) -> Option<&T> {
+    pub fn delete(&self,index:usize) -> Self {
-    self.head.as_ref().map(|node| &node.value)
+        //TODO: Implement Delete
-  }
+        List{head:None,tail:None}
+    }
 }