132 lines
3.9 KiB
C#
132 lines
3.9 KiB
C#
using C_.Datastructures.BinaryTree;
|
|
using C_.Datastructures.Stack;
|
|
using System;
|
|
|
|
namespace C_.Datastructures.BinaryTree
|
|
{
|
|
internal class Tree<T> where T:IComparable
|
|
{
|
|
public TreeNode<T>? Root { get; set; }
|
|
public int Count { get; set; }
|
|
|
|
public static Tree<T> Create(){
|
|
//Create a new Tree with no Head
|
|
return new Tree<T>{
|
|
Root = null,
|
|
Count = 0
|
|
};
|
|
}
|
|
|
|
public static Tree<T> Create(T value){
|
|
//Create a new Tree with Head
|
|
return new Tree<T>{
|
|
Root = TreeNode<T>.Create(value)
|
|
};
|
|
}
|
|
|
|
public void Add(T value)
|
|
{//Add item to the correct position in the tree (Input cannot be null)
|
|
Count++;
|
|
|
|
if (Root == default)
|
|
{//If new node should become the root
|
|
Root = TreeNode<T>.Create(value);
|
|
return;
|
|
}
|
|
|
|
//Find position to insert
|
|
TreeNode<T> node = Root;
|
|
node = Descend(value, node)!;
|
|
|
|
if (value.CompareTo(node.Value) < 0)
|
|
{//Insert to left
|
|
node.Left = TreeNode<T>.Create(value);
|
|
return;
|
|
}
|
|
//Insert to right
|
|
node.Right = TreeNode<T>.Create(value);
|
|
return;
|
|
}
|
|
|
|
private Stack<TreeNode<T>>? Find(T value)
|
|
{//Return true if the item can be found within the tree
|
|
if (Root == default || Root.Value!.Equals(default))
|
|
return default;
|
|
|
|
TreeNode<T>? current = Root;
|
|
|
|
Stack<TreeNode<T>>? stack = Stack<TreeNode<T>>.Create(Root);
|
|
|
|
while (stack.Peek() != default)
|
|
{
|
|
//Compare value at node to see if we are looking for the root item
|
|
if (stack.Peek()!.Value!.Equals(value))
|
|
return stack;
|
|
|
|
stack.Push(Traverse(value, stack.Peek()));
|
|
}
|
|
return default;
|
|
}
|
|
|
|
private Stack<TreeNode<T>>? Min(TreeNode<T>? node)
|
|
{//Returns a Stack with the value on top being the minimum of the subtree
|
|
|
|
if(node == default)
|
|
return default;
|
|
|
|
//Stack to store and be able to get the parent values
|
|
Stack<TreeNode<T>> stack = Stack<TreeNode<T>>.Create(node);
|
|
|
|
while(true){
|
|
if (stack.Peek()!.Left == default)
|
|
return stack;
|
|
|
|
stack.Push(stack.Peek()!.Left);
|
|
}
|
|
}
|
|
|
|
private Stack<TreeNode<T>>? Max(TreeNode<T>? node)
|
|
{///Returns a Stack with the value on top being the maximum of the subtree
|
|
if(node == default)
|
|
return default;
|
|
|
|
//Stack to store and be able to get the parent values
|
|
Stack<TreeNode<T>> stack = Stack<TreeNode<T>>.Create(node);
|
|
|
|
while(true){
|
|
if (stack.Peek()!.Right == default)
|
|
return stack;
|
|
|
|
stack.Push(stack.Peek()!.Right);
|
|
}
|
|
}
|
|
|
|
private TreeNode<T>? Traverse(T value, TreeNode<T>? node)
|
|
{//T is comparable so use methods to determine which way to traverse
|
|
if(node == default)
|
|
return default;
|
|
|
|
if (value.CompareTo(node.Value) < 0)
|
|
{//Traverse Left
|
|
return node.Left;
|
|
}
|
|
//Traverse Right
|
|
return node.Right;
|
|
}
|
|
|
|
private TreeNode<T>? Descend(T value, TreeNode<T>? current)
|
|
{//Keep trying to determine whether to go left or right until null node is found that can be appended to
|
|
if (current == default)
|
|
return default;
|
|
|
|
TreeNode<T>? node;
|
|
|
|
node = Descend(value, Traverse(value, current));
|
|
if (node == null)
|
|
{
|
|
return current;
|
|
}
|
|
return node;
|
|
}
|
|
}
|
|
} |