Struct AVL 

pub struct AVL<K: Ord, V> { /* private fields */ }

An AVL balanced tree with owned nodes.

Implementations

impl<K: Ord, V> AVL<K, V>

pub fn new() -> Self

Create an empty AVL tree

Examples

use ABtree::AVL;

let t = AVL::<i32, i32>::new();

pub fn add(&mut self, k: K, v: V)

Adding key-value pair into the tree

Example

use ABtree::AVL;
let mut t = AVL::<i32, i32>::new();
t.add(2, 3);
assert_eq!(t.len(), 1);

pub fn insert(&mut self, k: K, v: V)

Adding key-value pair into the tree this method is an alias of method add

Example

use ABtree::AVL;
let mut t = AVL::<i32, i32>::new();
t.insert(2, 3);
assert_eq!(t.len(), 1);

pub fn set(&mut self, k: K, v: V)

Setting a key-value pair if the key exists it will update the value otherwise it will insert the key-value into the tree

Example

use ABtree::AVL;
let mut t = AVL::<i32, i32>::new();
t.set(2, 2);
t.set(2, 31);
assert_eq!(t.get(&2), Some(&31));

pub fn len(&self) -> usize

Get the length of this tree

Example

use ABtree::AVL;
let mut t = AVL::<i32, i32>::new();
t.insert(2, 2);
t.insert(3, 3);
assert_eq!(t.len(), 2);

pub fn iter<'a>(&'a self) -> Iter<'a, K, V>

Provides a forward iterator.

Examples

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);

let mut iter = t.iter();
assert_eq!(iter.next(), Some((&0, &0)));
assert_eq!(iter.next(), Some((&1, &1)));
assert_eq!(iter.next_back(), Some((&2, &2)));

pub fn contains(&self, k: &K) -> bool

Containment check

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
assert!(t.contains(&1));

pub fn remove(&mut self, k: &K) -> Option<V>

Removing key-value pair

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
assert_eq!(t.remove(&1), Some(1));
assert_eq!(t.len(), 2);

pub fn peek_root<'a>(&'a self) -> Option<(&'a K, &'a V)>

Peeking the root node

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
assert_eq!(t.peek_root(), Some((&1, &1)));

pub fn is_balanced_tree(&self) -> bool

To check if shis tree is balanced

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
assert_eq!(t.is_balanced_tree(), true);

pub fn is_empty(&self) -> bool

To check if shis tree is empty

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
assert_eq!(t.is_empty(), false);

pub fn clear(&mut self)

Removes all elements from the AVL tree

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
t.clear();
assert_eq!(t.len(), 0);

pub fn get(&self, k: &K) -> Option<&V>

Get the value by key

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();

t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
assert_eq!(t.get(&1), Some(&1));

pub fn get_mut(&mut self, k: &K) -> Option<&mut V>

Get a mutable reference of value by key

Example

use ABtree::AVL;

let mut t: AVL<u32, u32> = AVL::new();
t.insert(0, 0);
t.insert(1, 1);
t.insert(2, 2);
let v = t.get_mut(&2);
v.map(|i| *i += 10);
assert_eq!(t.get(&2), Some(&12))

Trait Implementations

impl<K: Ord + Copy, V: Copy> Clone for AVL<K, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Ord, V> Drop for AVL<K, V>

Drop

fn drop(&mut self)

Executes the destructor for this type.

impl<K: Ord, V> FromIterator<(K, V)> for AVL<K, V>

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<K: Ord, V> IntoIterator for AVL<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Ord + Send, V: Send> Send for AVL<K, V>

impl<K: Ord + Sync, V: Sync> Sync for AVL<K, V>