Struct collections::linked_list::LinkedList
[−]
[src]
pub struct LinkedList<T> { length: usize, list_head: Link<T>, list_tail: Rawlink<Node<T>>, }
A doubly-linked list.
Fields
length | |
list_head | |
list_tail |
Methods
impl<T> LinkedList<T>
fn push_front_node(&mut self, new_head: Box<Node<T>>)
Add a Node first in the list
fn pop_front_node(&mut self) -> Option<Box<Node<T>>>
Remove the first Node and return it, or None if the list is empty
fn push_back_node(&mut self, new_tail: Box<Node<T>>)
Add a Node last in the list
fn pop_back_node(&mut self) -> Option<Box<Node<T>>>
Remove the last Node and return it, or None if the list is empty
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);