public void InOrderTraversal(BTNode node)
{
if (node == null)
return;
InOrderTraversal(node.left);
Console.Out.Write(node.value);
InOrderTraversal(node.right);
}
public BTNode ConstructBalancedRecurs(int[] values, int start, int end)
{
if (start > end)
return null;
int mid = end - start / 2;
BTNode node = new BTNode(null, null, values[mid]);
node.left = ConstructBalancedRecurs(values, start, mid - 1);
node.right = ConstructBalancedRecurs(values, mid + 1, end);
return node;
}
public int CheckLevel(BTNode node, int value)
{
if (node == null)
return 0;
if (value == (int)node.value)
return 1;
int left = CheckLevel(node.left, value);
int right = CheckLevel(node.right, value);
return Math.Max(left+1, right+1);
}
public bool IsBst(BTNode node)
{
if (node == null)
return true;
if (node.left != null && (int)node.left.value > (int)node.value)
return false;
if (node.right != null && (int)node.right.value < (int)node.value)
return false;
if (!IsBST(node.left) || !IsBST(node.right))
return false;
return true;
}
public void BFS(BTNode node)
{
if (node == null)
return;
Queue<BTNode> queue = new Queue<BTNode>();
queue.Enqueue(node);
while (queue.Count != 0)
{
BTNode current = queue.Dequeue();
Console.Out.Write(current.value);
if (node.left != null) queue.Enqueue(current.left);
if (node.right != null) queue.Enqueue(current.right);
}
}
public void DFS(BTNode node)
{
if (node == null)
return;
Stack<BTNode> stack = new Stack<BTNode>();
stack.Push(node);
while(stack.Count != 0)
{
BTNode current = stack.Pop();
Console.Out.Write(node.value);
if (node.left != null) stack.Push(current.left);
if (node.right != null) stack.Push(current.right);
}
}
public BTNode Delete(BTNode node, int value)
{
//Find the value
if (value < (int)node.value)
Delete(node.left, value);
if (value > (int)node.value)
Delete(node.right, value);
if ((int)node.value == value)
{
//No children
if (node.left == null && node.right == null)
node = null;
//1 child
else if (node.left == null)
{
BTNode temp = node.right;
node = temp;
temp = null;
}
else if (node.right == null)
{
BTNode temp = node.left;
node = temp;
temp = null;
}
//2 Children
else
{
BTNode temp = FindMin(node);
node = temp;
node.right = Delete(node.right, (int)temp.value);
}
}
return node;
}
public BTNode Search(BTNode node, int value)
{
if ((int)node.value == value)
{
return node;
}
if (value < (int)node.value)
Search(node.left, value);
if (value > (int)node.value)
Search(node.right, value);
return null;
}
public BTNode InsertRec(BTNode node, int value)
{
if (node == null)
{
node = new BTNode(null, null, value);
return node;
}
if (value < (int)node.value)
node.left = InsertRec(node.left, value);
if (value > (int)node.value)
node.right = InsertRec(node.right, value);
return node;
}
public BTNode FindMin(BTNode node)
{
if (node.left == null)
return node;
else
FindMin(node.left);
return node;
}
public BinaryTree(BTNode root)
{
Root = root;
}
//Check if BST... How about inorder traversal and checking if its sorted???
public bool IsBST(BTNode node)
{
if (node == null)
return true;
if (IsSubTreeLess(node.left, (int)node.value) &&
IsSubTreeGreater(node.right, (int)node.value) &&
IsBST(node.left) &&
IsBST(node.right))
return true;
else
return false;
}
public BTNode(BTNode left, BTNode right, int value)
{
this.left = left;
this.right = right;
this.value = value;
}
public BST(BTNode root)
: base(root)
{
}
public BTNode FindMax(BTNode node)
{
if (node.right == null)
return node;
else
FindMin(node.right);
return node;
}
public int FindHeight(BTNode node)
{
if (node == null)
//+1 will cause a leaf node will return 1, so need this to balance out
return -1;
return Math.Max(FindHeight(node.left), FindHeight(node.right)) + 1;
}
private bool IsSubTreeLess(BTNode node, int value)
{
if (node == null)
return true;
if (value > (int)node.value &&
IsSubTreeLess(node.left, value) && IsSubTreeLess(node.right, value))
return true;
else
return false;
}
