Struct LinkedList

pub struct LinkedList<T> {
    pub length: usize,
    /* private fields */
}

Fields

length: usize

Get length of linked list

Implementations

impl<T> LinkedList<T>

pub fn new() -> Self

Get new LinkedList

impl<T> LinkedList<T>

pub fn append(&mut self, data: T)

Append to the end of the linked list.

Time Complexity

O(n)

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.append(1);
 linked_list.append(2);
 linked_list.append(3);

 assert_eq!(format!("{}", linked_list), "HEAD -> 1 -> 2 -> 3 -> None");

pub fn insert(&mut self, data: T, posn: usize) -> Result<(), Error>

Insert elemet at posn in the linked list.

Time Complexity

O(posn)

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.insert(44, 0);
 linked_list.insert(22, 0);
 linked_list.insert(33, 1);

 assert_eq!(format!("{}", linked_list), "HEAD -> 22 -> 33 -> 44 -> None");

Errors

The function returns Error::PositionOutOfBounds(posn, len) if position to be inserted is >= linked list length.

pub fn prepend(&mut self, data: T)

Add element to the beginning of the linked list.

Time Complexity

O(1)

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.prepend(3);
 linked_list.prepend(2);
 linked_list.prepend(1);

 assert_eq!(format!("{}", linked_list), "HEAD -> 1 -> 2 -> 3 -> None");

impl<T> LinkedList<T>

pub fn delete_at_posn(&mut self, posn: usize) -> Result<(), Error>

Delete element at the given position.

Time Complexity

O(posn)

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.append(1);
 linked_list.append(2);
 linked_list.append(3);
 linked_list.append(4);

 linked_list.delete_at_posn(2);

 assert_eq!(format!("{}", linked_list), "HEAD -> 1 -> 2 -> 4 -> None");

Errors

The function returns Error::PositionOutOfBounds(posn, len) if position to be deleted is >= linked list length.

pub fn delete_where<F: FnMut(&T) -> bool>(&mut self, f: F) -> Result<(), Error>

Delete element at the given position.

Time Complexity

O(n)

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.append(1);
 linked_list.append(2);
 linked_list.append(3);
 linked_list.append(4);

 // delete first 2 elements
 let mut counter = 2;
 linked_list.delete_where(move |element| {
    counter -= 1;
    counter >= 0
 });

 assert_eq!(format!("{}", linked_list), "HEAD -> 3 -> 4 -> None");

 linked_list.delete_where(|element| element % 2 == 0);
 
 assert_eq!(format!("{}", linked_list), "HEAD -> 3 -> None");

Errors

The function returns Error::ElementDoesNotExist if no element of linked list returns true with closure f.

impl<T> LinkedList<T>

pub fn reverse(self) -> LinkedList<T>

Returns reversed linked list

Time Complexity

O(n)

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.append(1);
 linked_list.append(2);
 linked_list.append(3);
 linked_list.append(4);

 linked_list = linked_list.reverse();

 assert_eq!(format!("{}", linked_list), "HEAD -> 4 -> 3 -> 2 -> 1 -> None");

impl<T> LinkedList<T>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Produces mutable iterator

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.append(1);
 linked_list.append(2);
 linked_list.append(3);
 linked_list.append(4);

 linked_list.iter_mut().for_each(|element| *element += 1);

 assert_eq!(format!("{}", linked_list), "HEAD -> 2 -> 3 -> 4 -> 5 -> None");

pub fn iter(&self) -> Iter<'_, T>

Produces am immutable iterator

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.append(1);
 linked_list.append(2);
 linked_list.append(3);

 let mut vector = Vec::new();

 for element in linked_list.iter() {
    vector.push(*element);
 }

 assert_eq!(vector, [1, 2, 3]);

pub fn into_iter(self) -> IntoIter<T>

Consumes the linked list and gives an iterator.

Example

 let mut linked_list = LinkedList::<i32>::new();
 linked_list.append(1);
 linked_list.append(2);
 linked_list.append(3);

 let mut vector: Vec<i32> = linked_list.into_iter().collect();

 assert_eq!(vector, [1, 2, 3]);

Trait Implementations

impl<T: Debug> Debug for LinkedList<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Display> Display for LinkedList<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.