链表

A linked list is also a linear data structure, and each element in the linked list is actually a separate object while all the objects are linked together by the reference filed in each element. In a doubly linked list, each node contains, besides the next node link, a second link field pointing to the previous node in the sequence. The two links may be called next and prev. And many modern operating systems use doubly linked lists to maintain references to active processes, threads and other dynamic objects.

Properties

  • Indexing O(n)
  • Insertion O(1)
    • Beginning O(1)
    • Middle (Indexing time+O(1))
    • End O(n)
  • Deletion O(1)
    • Beginning O(1)
    • Middle (Indexing time+O(1))
    • End O(n)
  • Search O(n)
  1. use std::fmt::{self, Display, Formatter};
  2. use std::ptr::NonNull;
  4. struct Node<T> {
  5.     val: T,
  6.     next: Option<NonNull<Node<T>>>,
  7.     prev: Option<NonNull<Node<T>>>,
  8. }
  10. impl<T> Node<T> {
  11.     fn new(t: T) -> Node<T> {
  12.         Node {
  13.             val: t,
  14.             prev: None,
  15.             next: None,
  16.         }
  17.     }
  18. }
  20. pub struct LinkedList<T> {
  21.     length: u32,
  22.     start: Option<NonNull<Node<T>>>,
  23.     end: Option<NonNull<Node<T>>>,
  24. }
  26. impl<T> Default for LinkedList<T> {
  27.     fn default() -> Self {
  28.         Self::new()
  29.     }
  30. }
  32. impl<T> LinkedList<T> {
  33.     pub fn new() -> Self {
  34.         Self {
  35.             length: 0,
  36.             start: None,
  37.             end: None,
  38.         }
  39.     }
  41.     pub fn add(&mut self, obj: T) {
  42.         let mut node = Box::new(Node::new(obj));
  43.         // Since we are adding node at the end, next will always be None
  44.         node.next = None;
  45.         node.prev = self.end;
  46.         // Get a pointer to node
  47.         let node_ptr = Some(unsafe { NonNull::new_unchecked(Box::into_raw(node)) });
  48.         match self.end {
  49.             // This is the case of empty list
  50.             None => self.start = node_ptr,
  51.             Some(end_ptr) => unsafe { (*end_ptr.as_ptr()).next = node_ptr },
  52.         }
  53.         self.end = node_ptr;
  54.         self.length += 1;
  55.     }
  57.     pub fn get(&mut self, index: i32) -> Option<&T> {
  58.         self.get_ith_node(self.start, index)
  59.     }
  61.     fn get_ith_node(&mut self, node: Option<NonNull<Node<T>>>, index: i32) -> Option<&T> {
  62.         match node {
  63.             None => None,
  64.             Some(next_ptr) => match index {
  65.                 0 => Some(unsafe { &(*next_ptr.as_ptr()).val }),
  66.                 _ => self.get_ith_node(unsafe { (*next_ptr.as_ptr()).next }, index - 1),
  67.             },
  68.         }
  69.     }
  70. }
  72. impl<T> Display for LinkedList<T>
  73. where
  74.     T: Display,
  75. {
  76.     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  77.         match self.start {
  78.             Some(node) => write!(f, "{}", unsafe { node.as_ref() }),
  79.             None => Ok(()),
  80.         }
  81.     }
  82. }
  84. impl<T> Display for Node<T>
  85. where
  86.     T: Display,
  87. {
  88.     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  89.         match self.next {
  90.             Some(node) => write!(f, "{}, {}", self.val, unsafe { node.as_ref() }),
  91.             None => write!(f, "{}", self.val),
  92.         }
  93.     }
  94. }
  96. #[cfg(test)]
  97. mod tests {
  98.     use super::LinkedList;
  100.     #[test]
  101.     fn create_numeric_list() {
  102.         let mut list = LinkedList::<i32>::new();
  103.         list.add(1);
  104.         list.add(2);
  105.         list.add(3);
  106.         println!("Linked List is {}", list);
  107.         assert_eq!(3, list.length);
  108.     }
  110.     #[test]
  111.     fn create_string_list() {
  112.         let mut list_str = LinkedList::<String>::new();
  113.         list_str.add("A".to_string());
  114.         list_str.add("B".to_string());
  115.         list_str.add("C".to_string());
  116.         println!("Linked List is {}", list_str);
  117.         assert_eq!(3, list_str.length);
  118.     }
  120.     #[test]
  121.     fn get_by_index_in_numeric_list() {
  122.         let mut list = LinkedList::<i32>::new();
  123.         list.add(1);
  124.         list.add(2);
  125.         println!("Linked List is {}", list);
  126.         let retrived_item = list.get(1);
  127.         assert!(retrived_item.is_some());
  128.         assert_eq!(2 as i32, *retrived_item.unwrap());
  129.     }
  131.     #[test]
  132.     fn get_by_index_in_string_list() {
  133.         let mut list_str = LinkedList::<String>::new();
  134.         list_str.add("A".to_string());
  135.         list_str.add("B".to_string());
  136.         println!("Linked List is {}", list_str);
  137.         let retrived_item = list_str.get(1);
  138.         assert!(retrived_item.is_some());
  139.         assert_eq!("B", *retrived_item.unwrap());
  140.     }
  141. }