Struct SinglyLinkedList

pub struct SinglyLinkedList<T> { /* private fields */ }

A singly-linked list with owned nodes.

This implementation is a simplified version of std::forward_list in C++.

References:

• Rust Standard Library: std::collections::LinkedList
• Learning Rust With Entirely Too Many Linked Lists
• Stack Overflow: Deleting a node from singly linked list …
• Stack Exchange: Reversal of a singly-linked list in Rust

Implementations

impl<T> SinglyLinkedList<T>

pub fn new() -> Self

Constructs a new, empty SinglyLinkedList<T>.

The list will not allocate until elements are pushed onto it.

pub fn push_front(&mut self, elem: T)

Prepends the given element value to the beginning of the container.

Parameters

• elem - The element to prepend.

Complexity

Constant.

pub fn pop_front(&mut self) -> Option<T>

Removes and returns the first element of the container. If there are no elements in the container, return None.

Complexity

Constant.

pub fn insert_after(&mut self, pos: usize, elem: T) -> Result<(), usize>

Inserts an element after the specified position in the container.

If the position is out of bound, returns an Result:Err with the size of the list.

Parameters

• pos - The index after which the element will be inserted.
• elem - The element to be inserted.

Complexity

Search time O(n) + O(1).

pub fn remove(&mut self, pos: usize) -> Option<T>

Removes and returns an element at specified position from the container.

Parameters

• pos - The index at which the element will be moved.

Complexity

Search time O(n) + constant.

pub fn clear(&mut self)

Removes all elements from the container.

Complexity

Linear in the size of the container.

pub fn is_empty(&self) -> bool

Checks whether the container is empty.

Complexity

Constant.

pub fn len(&self) -> usize

Gets the number of elements in the container.

Complexity

Linear in the size of the container.

pub fn reverse(&mut self)

Reverses the order of the elements in the container.

Complexity

Linear in the size of the container.

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

Creates an iterator that yields immutable reference of each element.

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

Creates an iterator that yields mutable reference of each element.

Trait Implementations

impl<T: Debug> Debug for SinglyLinkedList<T>

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

Formats the value using the given formatter.

impl<T> Drop for SinglyLinkedList<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> IntoIterator for SinglyLinkedList<T>

fn into_iter(self) -> Self::IntoIter

Creates a consuming iterator, that is, one that moves each value out of the list (from start to end). The list cannot be used after calling this.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

impl<T: PartialEq> PartialEq for SinglyLinkedList<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.