Struct std::collections::LinkedList1.0.0 [−] [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

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

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

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

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 contains(&self, x: &T) -> bool where T: PartialEq<T>

Unstable (linked_list_contains #32630)

: recently added

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

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

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

Examples

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

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

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

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

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

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

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

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

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

fn front_place(&mut self) -> FrontPlace<T>

Unstable (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)] fn main() { use std::collections::LinkedList; let mut list = LinkedList::new(); list.front_place() <- 2; list.front_place() <- 4; assert!(list.iter().eq(&[4, 2])); }
#![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>

Unstable (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)] fn main() { use std::collections::LinkedList; let mut list = LinkedList::new(); list.back_place() <- 2; list.back_place() <- 4; assert!(list.iter().eq(&[2, 4])); }
#![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> Default for LinkedList<T>

fn default() -> LinkedList<T>

Returns the "default value" for a type. Read more

impl<T> Drop for LinkedList<T>

fn drop(&mut self)

A method called when the value goes out of scope. Read more

impl<A> FromIterator<A> for LinkedList<A>

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

Creates a value from an iterator. Read more

impl<T> IntoIterator for LinkedList<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Consumes the list into an iterator yielding elements by value.

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

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?

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

Creates an iterator from a value. Read more

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

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?

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

Creates an iterator from a value. Read more

impl<A> Extend<A> for LinkedList<A>

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

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

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

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

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

impl<A> PartialEq<LinkedList<A>> for LinkedList<A> where A: PartialEq<A>

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

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

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

This method tests for !=.

impl<A> Eq for LinkedList<A> where A: Eq

impl<A> PartialOrd<LinkedList<A>> for LinkedList<A> where A: PartialOrd<A>

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

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

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

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

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

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

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

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

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

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

impl<A> Ord for LinkedList<A> where A: Ord

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

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

impl<A> Clone for LinkedList<A> where A: Clone

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

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

impl<A> Debug for LinkedList<A> where A: Debug

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

Formats the value using the given formatter.

impl<A> Hash for LinkedList<A> where A: Hash

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

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.