Creates an empty LinkedList.
use std::collections::LinkedList;
let list: LinkedList<u32> = LinkedList::new();
[−]
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.
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());
[−]
Provides a forward iterator.
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);
[−]
Provides a forward iterator with mutable references.
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);
Returns true if the LinkedList is empty.
This operation should compute in O(1) time.
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert!(dl.is_empty());
dl.push_front("foo");
assert!(!dl.is_empty());
[−]
Returns the length of the LinkedList.
This operation should compute in O(1) time.
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);
Removes all elements from the LinkedList.
This operation should compute in O(n) time.
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);
Returns true if the LinkedList contains an element equal to the
given value.
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);
Provides a reference to the front element, or None if the list is
empty.
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert_eq!(dl.front(), None);
dl.push_front(1);
assert_eq!(dl.front(), Some(&1));
Provides a mutable reference to the front element, or None if the list
is empty.
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));
Provides a reference to the back element, or None if the list is
empty.
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert_eq!(dl.back(), None);
dl.push_back(1);
assert_eq!(dl.back(), Some(&1));
Provides a mutable reference to the back element, or None if the list
is empty.
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));
Adds an element first in the list.
This operation should compute in O(1) time.
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);
Removes the first element and returns it, or None if the list is
empty.
This operation should compute in O(1) time.
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);
Appends an element to the back of a list
use std::collections::LinkedList;
let mut d = LinkedList::new();
d.push_back(1);
d.push_back(3);
assert_eq!(3, *d.back().unwrap());
Removes the last element from a list and returns it, or None if
it is empty.
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));
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 if at > len.
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);
[−]
🔬 This is a nightly-only experimental API. (drain_filter #43244)
recently added
Creates an iterator which uses a closure to determine if an element should be removed.
If the closure returns true, then the element is removed and yielded.
If the closure returns false, the element will remain in the list and will not be yielded
by the iterator.
Note that drain_filter lets you mutate every element in the filter closure, regardless of
whether you choose to keep or remove it.
Splitting a list into evens and odds, reusing the original list:
#![feature(drain_filter)]
use std::collections::LinkedList;
let mut numbers: LinkedList<u32> = LinkedList::new();
numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]);
let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<LinkedList<_>>();
let odds = numbers;
assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![2, 4, 6, 8, 14]);
assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);