Struct collections::linked_list::LinkedList1.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]

[src]

Creates an empty LinkedList.

Examples

use std::collections::LinkedList;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[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> Send for LinkedList<T> where
    T: Send
[src]

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

[src]

impl<T> Debug for LinkedList<T> where
    T: Debug
[src]

[src]

Formats the value using the given formatter.

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

impl<'a, T> Extend<&'a T> for LinkedList<T> where
    T: 'a + Copy
1.2.0
[src]

[src]

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

[src]

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

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

[src]

[src]

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

[src]

Consumes the list into an iterator yielding elements by value.

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

Creates an empty LinkedList<T>.