Struct std::collections::linked_list::LinkedList
[−]
[src]
pub struct LinkedList<T> {
// some fields omitted
}1.0.0A 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>
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>
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>
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<A> Clone for LinkedList<A> where A: Clone
fn clone(&self) -> LinkedList<A>
fn clone_from(&mut self, source: &Self)
impl<A> Ord for LinkedList<A> where A: Ord
fn cmp(&self, other: &LinkedList<A>) -> Ordering
impl<A> PartialOrd<LinkedList<A>> for LinkedList<A> where A: PartialOrd<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> Eq for LinkedList<A> where A: Eq
impl<A> PartialEq<LinkedList<A>> for LinkedList<A> where A: PartialEq<A>
fn eq(&self, other: &LinkedList<A>) -> bool
fn ne(&self, other: &LinkedList<A>) -> bool
impl<'a, T> Extend<&'a T> for LinkedList<T> where T: Copy + 'a1.2.0
fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item=&'a T>
impl<A> Extend<A> for LinkedList<A>
fn extend<T>(&mut self, iter: T) where T: IntoIterator<Item=A>
impl<T> IntoIterator for LinkedList<T>
type Item = T
type IntoIter = IntoIter<T>
fn into_iter(self) -> IntoIter<T>
Consumes the list into an iterator yielding elements by value.