linked_list

Author: Lslightly

homework/src/arc.rs

@@ -296,7 +296,7 @@ impl<T> Arc<T> {
     /// ```
     #[inline]
     pub fn ptr_eq(this: &Self, other: &Self) -> bool {
-        this.ptr.as_ptr() == other.ptr.as_ptr()
+        std::ptr::eq(this.ptr.as_ptr(), other.ptr.as_ptr())
     }
 
     /// Returns the inner value, if the given `Arc` is unique.

homework/src/linked_list.rs

@@ -144,13 +144,38 @@ impl<T> LinkedList<T> {
     /// Adds the given node to the back of the list.
     #[inline]
     fn push_back_node(&mut self, mut node: Node<T>) {
-        todo!()
+        node.next = ptr::null_mut();
+        node.prev = self.tail;
+        let node = Box::into_raw(Box::new(node));
+
+        if self.tail.is_null() {
+            self.head = node;
+        } else {
+            unsafe { (*self.tail).next = node };
+        }
+
+        self.tail = node;
+        self.len += 1;
     }
 
     /// Removes and returns the node at the back of the list.
     #[inline]
     fn pop_back_node(&mut self) -> Option<Node<T>> {
-        todo!()
+        if self.tail.is_null() {
+            return None;
+        }
+
+        let node = unsafe { Box::from_raw(self.tail) };
+        self.tail = node.prev;
+
+        if self.tail.is_null() {
+            self.head = ptr::null_mut();
+        } else {
+            unsafe { (*self.tail).next = ptr::null_mut() };
+        }
+
+        self.len -= 1;
+        Some(*node)
     }
 }
 
@@ -257,7 +282,20 @@ impl<T> LinkedList<T> {
     /// assert!(list1.is_empty());
     /// ```
     pub fn prepend(&mut self, other: &mut Self) {
-        todo!()
+        if self.head.is_null() {
+            mem::swap(self, other);
+            return;
+        }
+        let other_head = mem::replace(&mut other.head, ptr::null_mut());
+        if !other_head.is_null() {
+            unsafe {
+                (*self.head).prev = other.tail;
+                (*other.tail).next = self.head;
+                self.head = other_head;
+            }
+            let _ = mem::replace(&mut other.tail, ptr::null_mut());
+            self.len += mem::replace(&mut other.len, 0);
+        }
     }
 
     /// Provides a forward iterator.
@@ -476,7 +514,7 @@ impl<T> LinkedList<T> {
     /// ```
     #[inline]
     pub fn back(&self) -> Option<&T> {
-        todo!()
+        unsafe { self.tail.as_ref() }.map(|node| &node.element)
     }
 
     /// Provides a mutable reference to the back element, or `None` if the list
@@ -522,7 +560,7 @@ impl<T> LinkedList<T> {
     /// assert_eq!(dl.front().unwrap(), &1);
     /// ```
     pub fn push_front(&mut self, elt: T) {
-        todo!()
+        self.push_front_node(Node::new(elt));
     }
 
     /// Removes the first element and returns it, or `None` if the list is
@@ -630,14 +668,30 @@ impl<'a, T> Iterator for IterMut<'a, T> {
 
     #[inline]
     fn next(&mut self) -> Option<&'a mut T> {
-        todo!()
+        if self.len == 0 {
+            None
+        } else {
+            unsafe { self.head.as_mut() }.map(|node| {
+                self.len -= 1;
+                self.head = node.next;
+                &mut node.element
+            })
+        }
     }
 }
 
 impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut T> {
-        todo!()
+        if self.len == 0 {
+            None
+        } else {
+            unsafe { self.tail.as_mut() }.map(|node| {
+                self.len -= 1;
+                self.tail = node.prev;
+                &mut node.element
+            })
+        }
     }
 }
 
@@ -666,7 +720,29 @@ impl<T> IterMut<'_, T> {
     /// ```
     #[inline]
     pub fn insert_next(&mut self, element: T) {
-        todo!()
+        // unsure if this is the correct way to insert an element
+        let mut node = Node::new(element);
+        node.next = self.head;
+        if node.next.is_null() {
+            node.prev = self.tail;
+        } else {
+            node.prev = unsafe { (*self.head).prev };
+        }
+        let prev = node.prev;
+        let next = node.next;
+        let node_ptr = Box::into_raw(Box::new(node));
+        if next.is_null() {
+            self.list.tail = node_ptr;
+            self.tail = node_ptr;
+        } else {
+            unsafe { (*next).prev = node_ptr };
+        }
+        if !prev.is_null() {
+            unsafe { (*prev).next = node_ptr };
+        } else {
+            self.list.head = node_ptr;
+        }
+        self.list.len += 1;
     }
 
     /// Provides a reference to the next element, without changing the iterator.
@@ -686,7 +762,11 @@ impl<T> IterMut<'_, T> {
     /// ```
     #[inline]
     pub fn peek_next(&mut self) -> Option<&mut T> {
-        todo!()
+        if !self.head.is_null() {
+            unsafe { self.head.as_mut() }.map(|node| &mut node.element)
+        } else {
+            None
+        }
     }
 }