Struct BinaryTree

pub struct BinaryTree<T>
where
    T: Clone + Ord + Eq + Debug,
{
    pub elem: Option<Box<T>>,
    pub right: Option<Box<BinaryTree<T>>>,
    pub left: Option<Box<BinaryTree<T>>>,
}

Generic Search Binary Tree implementation

Fields

elem: Option<Box<T>>

Pointer holding the data can be None

right: Option<Box<BinaryTree<T>>>

Pointer to the right leaf

left: Option<Box<BinaryTree<T>>>

Pointer to the left leaf

Implementations

impl<T> BinaryTree<T>

where T: Debug + Clone + Ord,

pub fn new(elem: T) -> Self

Creates a new BinaryTree<T>

Example

Basic usage:

let mut a = BinaryTree::new(1);

pub fn delete(&mut self, del_elem: T) -> Option<T>

Deletes and returns the given element from the tree in O(log n) If the element is not in the tree returns None Basic usage:

let mut a = BinaryTree::new(1);
let x = a.delete(1);
assert_eq!(Some(x), a);

pub fn insert(&mut self, new_elem: T)

Inserts the given element into the tree Time complexity -> O(log n) Basic usage:

let mut a = BinaryTree::new(1);
a.insert(1);

pub fn is_empty(&self) -> bool

Returns true if the list is empty Basic usage:

let mut a = BinaryTree::new(1);
let b = a.is_empty();
assert_eq!(b, false);

pub fn contains(&self, search_elem: T) -> bool

Returns true if the elemen is in the tree with O(log n) complexity Basic usage:

let mut a = BinaryTree::new(1);
let b = a.contains(1);
assert_eq!(b, true);

pub fn clear(&mut self)

Clears/Deallocates the tree entirely Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
a.clear();
assert_eq!(a.is_empty(), true);

pub fn max(&self) -> Option<&T>

Returns the maximum value of the tree in O(log n) Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
let x = a.max().unwrap();
assert_eq!(x, 2);

pub fn min(&self) -> Option<&T>

Returns the minimum value of the tree in O(log n) Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
let x = a.min().unwrap();
assert_eq!(x, 1);

pub fn height(&self) -> usize

Returns the height value of the tree in O(log n) Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
let x = a.height().unwrap();
assert_eq!(x, 1);

pub fn count(&self) -> usize

Returns the total number of elements in the tree in O(n) Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
let x = a.count().unwrap();
assert_eq!(x, 2);

pub fn inorder(&self)

Prints to screen the elements in inorder Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
a.inorder();

pub fn preorder(&self)

Prints to screen the elements in preorder Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
a.peorder();

pub fn postorder(&self)

Prints to screen the elements in postorder Basic usage:

let mut a = BinaryTree::new(1);
a.insert(2);
a.postorder();

pub fn vec_insert(&mut self, elems: Vec<T>)

Inserts all the elements in the vector in the tree Basic usage:

let mut a = BinaryTree::new(1);
a.vec_insert([1,2,3]);

Trait Implementations

impl<'a, T> IntoIterator for &'a BinaryTree<T>

where T: 'a + Clone + Ord + Eq + Debug,

fn into_iter(self) -> Self::IntoIter

Creates a iterator that iterates in INORDER Basic usage:

let mut a = BinaryTree::new(1);
a.vec_insert([1,2,3]);
for i in a.into_iter() {
    println!("{}", *i);
}

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = InOrderIter<'a, T>

Which kind of iterator are we turning this into?