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

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

A doubly-linked list.

## Methods

### `impl<T> LinkedList<T>`

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

Creates an empty `LinkedList`.

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

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

extern crate collections; fn main() { use std::collections::LinkedList; let mut a = LinkedList::new(); let mut b = LinkedList::new(); a.push_back(1); a.push_back(2); b.push_back(3); b.push_back(4); a.append(&mut b); for e in &a { println!("{}", e); // prints 1, then 2, then 3, then 4 } println!("{}", b.len()); // prints 0 }

    use std::collections::LinkedList;

    let mut a = LinkedList::new();
    let mut b = LinkedList::new();
    a.push_back(1);
    a.push_back(2);
    b.push_back(3);
    b.push_back(4);

    a.append(&mut b);

    for e in &a {
        println!("{}", e); // prints 1, then 2, then 3, then 4
    }
    println!("{}", b.len()); // prints 0

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

Provides a forward iterator.

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

Provides a forward iterator with mutable references.

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

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

This operation should compute in O(1) time.

# Examples

extern crate collections; fn main() { use std::collections::LinkedList; let mut dl = LinkedList::new(); assert!(dl.is_empty()); dl.push_front("foo"); assert!(!dl.is_empty()); }

    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`

Returns the length of the `LinkedList`.

This operation should compute in O(1) time.

# Examples

extern crate collections; fn main() { 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); }

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

Removes all elements from the `LinkedList`.

This operation should compute in O(n) time.

# Examples

extern crate collections; fn main() { 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); }

    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 front(&self) -> Option<&T>`

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

# Examples

extern crate collections; fn main() { use std::collections::LinkedList; let mut dl = LinkedList::new(); assert_eq!(dl.front(), None); dl.push_front(1); assert_eq!(dl.front(), Some(&1)); }

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

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

# Examples

extern crate collections; fn main() { 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)); }

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

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

# Examples

extern crate collections; fn main() { use std::collections::LinkedList; let mut dl = LinkedList::new(); assert_eq!(dl.back(), None); dl.push_back(1); assert_eq!(dl.back(), Some(&1)); }

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

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

# Examples

extern crate collections; fn main() { 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)); }

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

Adds an element first in the list.

This operation should compute in O(1) time.

# Examples

extern crate collections; fn main() { 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); }

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

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

This operation should compute in O(1) time.

# Examples

extern crate collections; fn main() { 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); }

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

Appends an element to the back of a list

# Examples

extern crate collections; fn main() { use std::collections::LinkedList; let mut d = LinkedList::new(); d.push_back(1); d.push_back(3); assert_eq!(3, *d.back().unwrap()); }

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

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

# Examples

extern crate collections; fn main() { 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)); }

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

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

# Panics

Panics if `at > len`.

This operation should compute in O(n) time.

# Examples

extern crate collections; fn main() { 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); }

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

## Trait Implementations

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

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

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

#### `fn drop(&mut self)`

### `impl<A> FromIterator<A> for LinkedList<A>`

#### `fn from_iter<T: IntoIterator<Item=A>>(iter: T) -> LinkedList<A>`

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

#### `type Item = T`

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

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

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

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

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

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

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

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

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

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

### `impl<A> Extend<A> for LinkedList<A>`

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

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

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

### `impl<A: PartialEq> PartialEq for LinkedList<A>`

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

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

### `impl<A: Eq> Eq for LinkedList<A>`

### `impl<A: PartialOrd> PartialOrd for LinkedList<A>`

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

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

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

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

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

### `impl<A: Ord> Ord for LinkedList<A>`

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

### `impl<A: Clone> Clone for LinkedList<A>`

#### `fn clone(&self) -> LinkedList<A>`

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

### `impl<A: Debug> Debug for LinkedList<A>`

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

### `impl<A: Hash> Hash for LinkedList<A>`

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

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

# 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

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