Struct ABtree::AVL[−][src]

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

Expand description

An AVL balanced tree with owned nodes.

Implementations

[src]

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

[src]

pub fn new() -> Self

Create an empty AVL tree

Examples

use ABtree::AVL;

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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