// private find, if current node is null return false,if current node is item return true
// if current node is greater than item call find on left subtree, if lesser call find on right subtree
private bool Find(T item, BinarySearchTreeNode <T> root)
{
if (root == null)
{
return(false);
}
else if (item.CompareTo(root.value) == 0)
{
return(true);
}
else if (item.CompareTo(root.value) < 0)
{
return(Find(item, root.left));
}
else
{
return(Find(item, root.right));
}
}
// Deletes given node
private BinarySearchTreeNode <T> DeleteNode(BinarySearchTreeNode <T> root)
{
// if node has no children simply delete
if (root.left == null && root.right == null)
{
return(null);
}
// if node has only one child replace it with child
if (root.right == null)
{
root.left.parent = root.parent;
return(root.left);
}
if (root.left == null)
{
root.right.parent = root.parent;
return(root.right);
}
// if node has 2 children replace with next smallest node
return(ReplaceNode(root));
}
// in order traversal, returns a string containing all elements
// implemented making use of the parent nodes to test their functionality
public string ParentTraverse()
{
BinarySearchTreeNode <T> current = root;
BinarySearchTreeNode <T> previous;
string output = "";
if (current == null)
{
return(output);
}
// loops until returning to root from the right or from left if there is no right branch
do
{
// moves to furthest left child of current and adds its value to output, sets previous to current
while (current.left != null)
{
current = current.left;
}
previous = current;
output += current.value + " ";
// traverses parent nodes until reaching a node with an unvisited right node or reaching the root
while ((current.right == null || current.right == previous) && current.parent != null)
{
// sets previous to current then sets current to parent and adds value to output if previous was not on right side
previous = current;
current = current.parent;
if (current.right != previous)
{
output += current.value + " ";
}
}
// if there is an unvisited branch to the right, moves current to right
if (current.right != previous && current.right != null)
{
current = current.right;
}
} while (current.parent != null);
return(output);
}
//private insert, takes a node and item and attempts to insert at that node
// if node is not empty recurses on left/right node if item is smaller/larger than item at current position
private BinarySearchTreeNode <T> Insert(BinarySearchTreeNode <T> root, T item)
{
if (root == null)
{
root = new BinarySearchTreeNode <T>();
root.value = item;
}
// insertion logic, if the value (v )is < root, insert to the root.left
// otherwise it's >=, so insert to the right
// connects node to parent after
else if (item.CompareTo(root.value) < 0)
{
root.left = Insert(root.left, item);
root.left.parent = root;
}
else
{
root.right = Insert(root.right, item);
root.right.parent = root;
}
return(root);
}
// private delete, finds if item is in tree and if so deletes it
private BinarySearchTreeNode <T> Delete(T item, BinarySearchTreeNode <T> root)
{
// if current node is null end search
if (root != null)
{
// if current node is item, delete it
if (item.CompareTo(root.value) == 0)
{
return(DeleteNode(root));
}
// otherwise attempt to delete from left/right subtree if item is lesser/greater than current node
if (item.CompareTo(root.value) < 0)
{
root.left = Delete(item, root.left);
}
else
{
root.right = Delete(item, root.right);
}
}
return(root);
}
// public insert, takes an item and calls private insert on item at root
public void Insert(T item)
{
root = Insert(root, item);
}
// public delete, calls private delete on given item
public void Delete(T item)
{
root = Delete(item, root);
}