std::collections::linked_list::LinkedList - Rust
Description: API documentation for the Rust `LinkedList` struct in crate `std`.
Keywords: rust, rustlang, rust-lang, LinkedList

# 1.0.0[−][src]Struct std::collections::linked_list::LinkedList

    pub struct LinkedList<T> { /* fields omitted */ }

A doubly-linked list with owned nodes.

The `LinkedList` allows pushing and popping elements at either end in constant time.

Almost always it is better to use `Vec` or `VecDeque` instead of `LinkedList`. In general, array-based containers are faster, more memory efficient and make better use of CPU cache.

## Methods

###

`impl<T> LinkedList<T>`

[src]

####

`pub fn new() -> LinkedList<T>`

[src]

Creates an empty `LinkedList`.

# Examples

    use std::collections::LinkedList;

    let list: LinkedList<u32> = LinkedList::new();Run

####

`pub fn append(&mut self, other: &mut LinkedList<T>)`

[src]

Moves all elements from `other` to the end of the list.

This reuses all the nodes from `other` and moves them into `self`. After this operation, `other` becomes empty.

This operation should compute in O(1) time and O(1) memory.

# Examples

    use std::collections::LinkedList;

    let mut list1 = LinkedList::new();
    list1.push_back('a');

    let mut list2 = LinkedList::new();
    list2.push_back('b');
    list2.push_back('c');

    list1.append(&mut list2);

    let mut iter = list1.iter();
    assert_eq!(iter.next(), Some(&'a'));
    assert_eq!(iter.next(), Some(&'b'));
    assert_eq!(iter.next(), Some(&'c'));
    assert!(iter.next().is_none());

    assert!(list2.is_empty());Run

####
ⓘImportant traits for Iter<'a, T>

### Important traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`

`pub fn iter(&self) -> Iter<T>`

[src]

Provides a forward iterator.

# Examples

    use std::collections::LinkedList;

    let mut list: LinkedList<u32> = LinkedList::new();

    list.push_back(0);
    list.push_back(1);
    list.push_back(2);

    let mut iter = list.iter();
    assert_eq!(iter.next(), Some(&0));
    assert_eq!(iter.next(), Some(&1));
    assert_eq!(iter.next(), Some(&2));
    assert_eq!(iter.next(), None);Run

####
ⓘImportant traits for IterMut<'a, T>

### Important traits for IterMut<'a, T>

`impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;`

`pub fn iter_mut(&mut self) -> IterMut<T>`

[src]

Provides a forward iterator with mutable references.

# Examples

    use std::collections::LinkedList;

    let mut list: LinkedList<u32> = LinkedList::new();

    list.push_back(0);
    list.push_back(1);
    list.push_back(2);

    for element in list.iter_mut() {
        *element += 10;
    }

    let mut iter = list.iter();
    assert_eq!(iter.next(), Some(&10));
    assert_eq!(iter.next(), Some(&11));
    assert_eq!(iter.next(), Some(&12));
    assert_eq!(iter.next(), None);Run

####

`pub fn is_empty(&self) -> bool`

[src]

Returns `true` if the `LinkedList` is empty.

This operation should compute in O(1) time.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();
    assert!(dl.is_empty());

    dl.push_front("foo");
    assert!(!dl.is_empty());Run

####

`pub fn len(&self) -> usize`

[src]

Returns the length of the `LinkedList`.

This operation should compute in O(1) time.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();

    dl.push_front(2);
    assert_eq!(dl.len(), 1);

    dl.push_front(1);
    assert_eq!(dl.len(), 2);

    dl.push_back(3);
    assert_eq!(dl.len(), 3);Run

####

`pub fn clear(&mut self)`

[src]

Removes all elements from the `LinkedList`.

This operation should compute in O(n) time.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();

    dl.push_front(2);
    dl.push_front(1);
    assert_eq!(dl.len(), 2);
    assert_eq!(dl.front(), Some(&1));

    dl.clear();
    assert_eq!(dl.len(), 0);
    assert_eq!(dl.front(), None);Run

####

`pub fn contains(&self, x: &T) -> bool where T: PartialEq<T>,`

1.12.0
[src]

Returns `true` if the `LinkedList` contains an element equal to the given value.

# Examples

    use std::collections::LinkedList;

    let mut list: LinkedList<u32> = LinkedList::new();

    list.push_back(0);
    list.push_back(1);
    list.push_back(2);

    assert_eq!(list.contains(&0), true);
    assert_eq!(list.contains(&10), false);Run

####

`pub fn front(&self) -> Option<&T>`

[src]

Provides a reference to the front element, or `None` if the list is empty.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();
    assert_eq!(dl.front(), None);

    dl.push_front(1);
    assert_eq!(dl.front(), Some(&1));Run

####

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

[src]

Provides a mutable reference to the front element, or `None` if the list is empty.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();
    assert_eq!(dl.front(), None);

    dl.push_front(1);
    assert_eq!(dl.front(), Some(&1));

    match dl.front_mut() {
        None => {},
        Some(x) => *x = 5,
    }
    assert_eq!(dl.front(), Some(&5));Run

####

`pub fn back(&self) -> Option<&T>`

[src]

Provides a reference to the back element, or `None` if the list is empty.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();
    assert_eq!(dl.back(), None);

    dl.push_back(1);
    assert_eq!(dl.back(), Some(&1));Run

####

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

[src]

Provides a mutable reference to the back element, or `None` if the list is empty.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();
    assert_eq!(dl.back(), None);

    dl.push_back(1);
    assert_eq!(dl.back(), Some(&1));

    match dl.back_mut() {
        None => {},
        Some(x) => *x = 5,
    }
    assert_eq!(dl.back(), Some(&5));Run

####

`pub fn push_front(&mut self, elt: T)`

[src]

Adds an element first in the list.

This operation should compute in O(1) time.

# Examples

    use std::collections::LinkedList;

    let mut dl = LinkedList::new();

    dl.push_front(2);
    assert_eq!(dl.front().unwrap(), &2);

    dl.push_front(1);
    assert_eq!(dl.front().unwrap(), &1);Run

####

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

[src]

Removes the first element and returns it, or `None` if the list is empty.

This operation should compute in O(1) time.

# Examples

    use std::collections::LinkedList;

    let mut d = LinkedList::new();
    assert_eq!(d.pop_front(), None);

    d.push_front(1);
    d.push_front(3);
    assert_eq!(d.pop_front(), Some(3));
    assert_eq!(d.pop_front(), Some(1));
    assert_eq!(d.pop_front(), None);Run

####

`pub fn push_back(&mut self, elt: T)`

[src]

Appends an element to the back of a list

# Examples

    use std::collections::LinkedList;

    let mut d = LinkedList::new();
    d.push_back(1);
    d.push_back(3);
    assert_eq!(3, *d.back().unwrap());Run

####

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

[src]

Removes the last element from a list and returns it, or `None` if it is empty.

# Examples

    use std::collections::LinkedList;

    let mut d = LinkedList::new();
    assert_eq!(d.pop_back(), None);
    d.push_back(1);
    d.push_back(3);
    assert_eq!(d.pop_back(), Some(3));Run

####

`pub fn split_off(&mut self, at: usize) -> LinkedList<T>`

[src]

Splits the list into two at the given index. Returns everything after the given index, including the index.

This operation should compute in O(n) time.

# Panics

Panics if `at > len`.

# Examples

    use std::collections::LinkedList;

    let mut d = LinkedList::new();

    d.push_front(1);
    d.push_front(2);
    d.push_front(3);

    let mut splitted = d.split_off(2);

    assert_eq!(splitted.pop_front(), Some(1));
    assert_eq!(splitted.pop_front(), None);Run

####
ⓘImportant traits for DrainFilter<'a, T, F>

### Important traits for DrainFilter<'a, T, F>

`impl<'a, T, F> Iterator for DrainFilter<'a, T, F> where
F: FnMut(&mut T) -> bool, type Item = T;`

`pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F> where F: FnMut(&mut T) -> bool,`

[src]

🔬 This is a nightly-only experimental API. (`drain_filter` #43244)

recently added

Creates an iterator which uses a closure to determine if an element should be removed.

If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the list and will not be yielded by the iterator.

Note that `drain_filter` lets you mutate every element in the filter closure, regardless of whether you choose to keep or remove it.

# Examples

Splitting a list into evens and odds, reusing the original list:

    #![feature(drain_filter)]
    use std::collections::LinkedList;

    let mut numbers: LinkedList<u32> = LinkedList::new();
    numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]);

    let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<LinkedList<_>>();
    let odds = numbers;

    assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![2, 4, 6, 8, 14]);
    assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);Run

## Trait Implementations

###

`impl<T> Clone for LinkedList<T> where T: Clone,`

[src]

####

`fn clone(&self) -> LinkedList<T>`

[src]

Returns a copy of the value. Read more

####

`fn clone_from(&mut self, source: &Self)`

[src]

Performs copy-assignment from `source`. Read more

###

`impl<'a, T> IntoIterator for &'a mut LinkedList<T>`

[src]

#### `type Item = &'a mut T`

The type of the elements being iterated over.

#### `type IntoIter = IterMut<'a, T>`

Which kind of iterator are we turning this into?

####
ⓘImportant traits for IterMut<'a, T>

### Important traits for IterMut<'a, T>

`impl<'a, T> Iterator for IterMut<'a, T> type Item = &'a mut T;`

`fn into_iter(self) -> IterMut<'a, T>`

[src]

Creates an iterator from a value. Read more

###

`impl<T> IntoIterator for LinkedList<T>`

[src]

#### `type Item = T`

The type of the elements being iterated over.

#### `type IntoIter = IntoIter<T>`

Which kind of iterator are we turning this into?

####
ⓘImportant traits for IntoIter<T>

### Important traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`

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

[src]

Consumes the list into an iterator yielding elements by value.

###

`impl<'a, T> IntoIterator for &'a LinkedList<T>`

[src]

#### `type Item = &'a T`

The type of the elements being iterated over.

#### `type IntoIter = Iter<'a, T>`

Which kind of iterator are we turning this into?

####
ⓘImportant traits for Iter<'a, T>

### Important traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`

`fn into_iter(self) -> Iter<'a, T>`

[src]

Creates an iterator from a value. Read more

###

`impl<T> Send for LinkedList<T> where T: Send,`

[src]

###

`impl<T> Hash for LinkedList<T> where T: Hash,`

[src]

####

`fn hash<H>(&self, state: &mut H) where H: Hasher,`

[src]

Feeds this value into the given [`Hasher`]. Read more

####

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,`

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<T> Extend<T> for LinkedList<T>`

[src]

####

`fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item = T>,`

[src]

Extends a collection with the contents of an iterator. Read more

###

`impl<'a, T> Extend<&'a T> for LinkedList<T> where T: 'a + Copy,`

1.2.0
[src]

####

`fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item = &'a T>,`

[src]

Extends a collection with the contents of an iterator. Read more

###

`impl<T> Sync for LinkedList<T> where T: Sync,`

[src]

###

`impl<T> Drop for LinkedList<T>`

[src]

####

`fn drop(&mut self)`

[src]

Executes the destructor for this type. Read more

###

`impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where T: PartialEq<T>,`

[src]

####

`fn eq(&self, other: &LinkedList<T>) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`fn ne(&self, other: &LinkedList<T>) -> bool`

[src]

This method tests for `!=`.

###

`impl<T> Eq for LinkedList<T> where T: Eq,`

[src]

###

`impl<T> FromIterator<T> for LinkedList<T>`

[src]

####

`fn from_iter<I>(iter: I) -> LinkedList<T> where I: IntoIterator<Item = T>,`

[src]

Creates a value from an iterator. Read more

###

`impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where T: PartialOrd<T>,`

[src]

####

`fn partial_cmp(&self, other: &LinkedList<T>) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<T> Ord for LinkedList<T> where T: Ord,`

[src]

####

`fn cmp(&self, other: &LinkedList<T>) -> Ordering`

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<T> Default for LinkedList<T>`

[src]

####

`fn default() -> LinkedList<T>`

[src]

Creates an empty `LinkedList<T>`.

###

`impl<T> Debug for LinkedList<T> where T: Debug,`

[src]

####

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

[src]

Formats the value using the given formatter. Read more

## Blanket Implementations

###

`impl<I> IntoIterator for I where I: Iterator,`

[src]

#### `type Item = <I as Iterator>::Item`

The type of the elements being iterated over.

#### `type IntoIter = I`

Which kind of iterator are we turning this into?

####

`fn into_iter(self) -> I`

[src]

Creates an iterator from a value. Read more

###

`impl<T, U> TryFrom for T where T: From<U>,`

[src]

#### `type Error = !`

🔬 This is a nightly-only experimental API. (`try_from` #33417)

The type returned in the event of a conversion error.

####

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

[src]

🔬 This is a nightly-only experimental API. (`try_from` #33417)

Performs the conversion.

###

`impl<T> From for T`

[src]

####

`fn from(t: T) -> T`

[src]

Performs the conversion.

###

`impl<T, U> TryInto for T where U: TryFrom<T>,`

[src]

#### `type Error = <U as TryFrom<T>>::Error`

🔬 This is a nightly-only experimental API. (`try_from` #33417)

The type returned in the event of a conversion error.

####

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

[src]

🔬 This is a nightly-only experimental API. (`try_from` #33417)

Performs the conversion.

###

`impl<T, U> Into for T where U: From<T>,`

[src]

####

`fn into(self) -> U`

[src]

Performs the conversion.

###

`impl<T> Borrow for T where T: ?Sized,`

[src]

####
ⓘImportant traits for &'a mut I

### Important traits for &'a mut I

`impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'a, R: Read + ?Sized> Read for &'a mut Rimpl<'a, W: Write + ?Sized> Write for &'a mut W`

`fn borrow(&self) -> &T`

[src]

Immutably borrows from an owned value. Read more

###

`impl<T> BorrowMut for T where T: ?Sized,`

[src]

####
ⓘImportant traits for &'a mut I

### Important traits for &'a mut I

`impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'a, R: Read + ?Sized> Read for &'a mut Rimpl<'a, W: Write + ?Sized> Write for &'a mut W`

`fn borrow_mut(&mut self) -> &mut T`

[src]

Mutably borrows from an owned value. Read more

###

`impl<T> Any for T where T: 'static + ?Sized,`

[src]

####

`fn get_type_id(&self) -> TypeId`

[src]

🔬 This is a nightly-only experimental API. (`get_type_id` #27745)

this method will likely be replaced by an associated static

Gets the `TypeId` of `self`. Read more

###

`impl<T> ToOwned for T where T: Clone,`

[src]

#### `type Owned = T`

####

`fn to_owned(&self) -> T`

[src]

Creates owned data from borrowed data, usually by cloning. Read more

####

`fn clone_into(&self, target: &mut T)`

[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)