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

    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]

#### `fn new() -> LinkedList<T>`
[src]

Creates an empty `LinkedList`.

# Examples

    use std::collections::LinkedList;

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

#### `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());

#### `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);

#### `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);

#### `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());

#### `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);

#### `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);

#### `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);

#### `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));

#### `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));

#### `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));

#### `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));

#### `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);

#### `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);

#### `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());

#### `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));

#### `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);

#### `fn front_place(&mut self) -> FrontPlace<T>`
[src]

🔬 This is a nightly-only experimental API. (`collection_placement` #30172)

method name and placement protocol are subject to change

Returns a place for insertion at the front of the list.

Using this method with placement syntax is equivalent to `push_front`, but may be more efficient.

# Examples

    #![feature(collection_placement)]
    #![feature(placement_in_syntax)]

    use std::collections::LinkedList;

    let mut list = LinkedList::new();
    list.front_place() <- 2;
    list.front_place() <- 4;
    assert!(list.iter().eq(&[4, 2]));

#### `fn back_place(&mut self) -> BackPlace<T>`
[src]

🔬 This is a nightly-only experimental API. (`collection_placement` #30172)

method name and placement protocol are subject to change

Returns a place for insertion at the back of the list.

Using this method with placement syntax is equivalent to `push_back`, but may be more efficient.

# Examples

    #![feature(collection_placement)]
    #![feature(placement_in_syntax)]

    use std::collections::LinkedList;

    let mut list = LinkedList::new();
    list.back_place() <- 2;
    list.back_place() <- 4;
    assert!(list.iter().eq(&[2, 4]));

## Trait Implementations

### `impl<T> Drop for LinkedList<T>`
[src]

#### `fn drop(&mut self)`
[src]

### `impl<T> Send for LinkedList<T> where
T: Send,`
[src]

### `impl<T> Clone for LinkedList<T> where
T: Clone,`
[src]

#### `fn clone(&self) -> LinkedList<T>`
[src]

### `impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,`
[src]

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

### `impl<'a, T> IntoIterator for &'a mut LinkedList<T>`
[src]

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

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

#### `fn into_iter(self) -> IterMut<'a, T>`
[src]

### `impl<'a, T> IntoIterator for &'a LinkedList<T>`
[src]

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

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

#### `fn into_iter(self) -> Iter<'a, T>`
[src]

### `impl<T> IntoIterator for LinkedList<T>`
[src]

#### `type Item = T`

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

#### `fn into_iter(self) -> IntoIter<T>`
[src]

Consumes the list into an iterator yielding elements by value.

### `impl<T> Sync for LinkedList<T> where
T: Sync,`
[src]

### `impl<T> Ord for LinkedList<T> where
T: Ord,`
[src]

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

### `impl<T> Eq for LinkedList<T> where
T: Eq,`
[src]

### `impl<T> Default for LinkedList<T>`
[src]

#### `fn default() -> LinkedList<T>`
[src]

Creates an empty `LinkedList<T>`.

### `impl<T> PartialEq<LinkedList<T>> for LinkedList<T> where
T: PartialEq<T>,`
[src]

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

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

### `impl<T> FromIterator<T> for LinkedList<T>`
[src]

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

### `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.

### `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]

### `impl<T> Extend<T> for LinkedList<T>`
[src]

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

### `impl<T> Hash for LinkedList<T> where
T: Hash,`
[src]

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

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand 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`)