private void PreOrderIteractive(TreeNodeInt node)
{
Stack <TreeNodeInt> stack = new Stack <TreeNodeInt>();
stack.Push(node);
while (stack.Count > 0)
{
node = stack.Pop();
//process node
//add right child
if (node.right != null)
{
stack.Push(node.right);
}
//add left child
if (node.left != null)
{
stack.Push(node.left);
}
}
}
//http://leetcode.com/2010/04/binary-search-tree-in-order-traversal.html
private void InOrderIteractive(TreeNodeInt node, List <int> list)
{
if (node == null)
{
return;
}
Stack <TreeNodeInt> stack = new Stack <TreeNodeInt>();
while (stack.Count > 0 || node != null)
{
//while there's a left child, keep going left
if (node != null)
{
stack.Push(node);
node = node.left;
}
//if there's no more left, process current node and then right side
else
{
node = stack.Pop();
list.Add(node.data);
node = node.right;
}
}
}
public static bool UnbalancedBinary(TreeNodeInt node)
{
if (node == null)
{
return true;
} else
{
bool result = true;
if (node.left != null) result = result && (node.left.data <= node.data);
if (node.right != null) result = result && (node.right.data > node.data);
return result && UnbalancedBinary(node.left) && UnbalancedBinary(node.right);
}
}
public static void BuildTree()
{
TreeNodeInt n20 = new TreeNodeInt(20); TreeNodeInt n10 = new TreeNodeInt(10); TreeNodeInt n25 = new TreeNodeInt(25); TreeNodeInt n30 = new TreeNodeInt(30);
TreeNodeInt n5 = new TreeNodeInt(5);
n20.left = n10;
n20.right = n30;
//n10.right = n25;
//n30.left = n5;
int max, min;
//Console.WriteLine("CheckBalanced = " + CheckBalanced(n20, out max, out min));
//Console.WriteLine("UnbalancedBinary = " + UnbalancedBinary(n20));
Console.WriteLine("CheckBalancedBook = " + CheckBalancedBook(n20, int.MinValue, int.MaxValue));
}
public static void BuildTree()
{
TreeNodeInt n20 = new TreeNodeInt(20); TreeNodeInt n10 = new TreeNodeInt(10); TreeNodeInt n25 = new TreeNodeInt(25); TreeNodeInt n30 = new TreeNodeInt(30);
TreeNodeInt n5 = new TreeNodeInt(5);
n20.left = n10;
n20.right = n30;
//n10.right = n25;
//n30.left = n5;
int max, min;
//Console.WriteLine("CheckBalanced = " + CheckBalanced(n20, out max, out min));
//Console.WriteLine("UnbalancedBinary = " + UnbalancedBinary(n20));
Console.WriteLine("CheckBalancedBook = " + CheckBalancedBook(n20, int.MinValue, int.MaxValue));
}
private void InOrderRecursive(TreeNodeInt node, List <int> list)
{
if (node == null)
{
return;
}
//process left child
InOrderRecursive(node.left, list);
//process self
list.Add(node.data);
//process right child
InOrderRecursive(node.right, list);
}
//http://www.geeksforgeeks.org/inorder-tree-traversal-without-recursion-and-without-stack/
private void InOrderIteractiveNoStack(TreeNodeInt current, List <int> list)
{
if (current == null)
{
return;
}
TreeNodeInt predecessor = null;
while (current != null)
{
//if there's no left child, process node and move right
if (current.left == null)
{
list.Add(current.data);
current = current.right;
}
else
{
//there's a left node
//find the inorder predecessor of current
predecessor = current.left;
while (predecessor.right != null && predecessor.right != current)
{
predecessor = predecessor.right;
}
// Make current as right child of its inorder predecessor
if (predecessor.right == null)
{
//we can now move to the left side of the tree because prodecessor.right hold a referent to current
//and at some point we'll process predecessor and the next after that is current
predecessor.right = current;
current = current.left;
}
else
{
//Revert the changes made in if part to restore the original
//tree i.e., fix the right child of predecssor
predecessor.right = null;
list.Add(current.data);
current = current.right;
}
}
}
}
/// <summary>
/// Adds an element to the tree.
/// </summary>
public void Add(int x)
{
//empty tree
if (root == null)
{
root = new TreeNodeInt(x);
return;
}
bool found = false;
TreeNodeInt current = root;
while (!found)
{
if (x <= current.data)
{
//found empty left spot
if (current.left == null)
{
current.left = new TreeNodeInt(x);
found = true;
}
else
{
//go left on the tree
current = current.left;
}
}
else
{
//found empty left spot
if (current.right == null)
{
current.right = new TreeNodeInt(x);
found = true;
}
else
{
//go left on the tree
current = current.right;
}
}
}
}
/// <summary>
/// Adds an element to the tree.
/// </summary>
public void Add(int x)
{
//empty tree
if (root == null)
{
root = new TreeNodeInt(x);
return;
}
bool found = false;
TreeNodeInt current = root;
while (!found)
{
if (x <= current.data)
{
//found empty left spot
if (current.left == null)
{
current.left = new TreeNodeInt(x);
found = true;
}
else
{
//go left on the tree
current = current.left;
}
}
else
{
//found empty left spot
if (current.right == null)
{
current.right = new TreeNodeInt(x);
found = true;
}
else
{
//go left on the tree
current = current.right;
}
}
}
}
public static bool CheckBalancedBook(TreeNodeInt node, int min, int max)
{
if (node == null)
{
return(true);
}
if (node.data <= min || node.data > max)
{
return(false);
}
if (!CheckBalancedBook(node.left, min, node.data) || !CheckBalancedBook(node.right, node.data, max))
{
return(false);
}
return(true);
}
public static bool CheckBalancedBook(TreeNodeInt node, int min, int max)
{
if (node == null)
{
return true;
}
if (node.data <= min || node.data > max)
{
return false;
}
if (!CheckBalancedBook(node.left, min, node.data) || !CheckBalancedBook(node.right, node.data, max))
{
return false;
}
return true;
}
public static bool UnbalancedBinary(TreeNodeInt node)
{
if (node == null)
{
return(true);
}
else
{
bool result = true;
if (node.left != null)
{
result = result && (node.left.data <= node.data);
}
if (node.right != null)
{
result = result && (node.right.data > node.data);
}
return(result && UnbalancedBinary(node.left) && UnbalancedBinary(node.right));
}
}
public static bool CheckBalanced(TreeNodeInt node, out int max, out int min)
{
max = node.data;
min = node.data;
int maxLeft = 0, maxRight = 0;
int minLeft = 0, minRight = 0;
bool result = true;
if (node.left != null)
{
result = result && CheckBalanced(node.left, out maxLeft, out minLeft) && (maxLeft <= node.data);
max = Math.Max(max, maxLeft);
min = Math.Min(min, minLeft);
}
if (node.right != null)
{
result = result && CheckBalanced(node.right, out maxRight, out minRight) && (minRight > node.data);
max = Math.Max(max, maxRight);
min = Math.Min(min, minRight);
}
return(result);
}
public static bool CheckBalanced(TreeNodeInt node, out int max, out int min)
{
max = node.data;
min = node.data;
int maxLeft = 0, maxRight = 0;
int minLeft = 0, minRight = 0;
bool result = true;
if (node.left != null)
{
result = result && CheckBalanced(node.left, out maxLeft, out minLeft) && (maxLeft <= node.data);
max = Math.Max(max, maxLeft);
min = Math.Min(min, minLeft);
}
if (node.right != null)
{
result = result && CheckBalanced(node.right, out maxRight, out minRight) && (minRight > node.data);
max = Math.Max(max, maxRight);
min = Math.Min(min, minRight);
}
return result;
}
//http://leetcode.com/2010/04/binary-search-tree-in-order-traversal.html
private void InOrderIteractive(TreeNodeInt node, List<int> list)
{
if (node == null)
{
return;
}
Stack<TreeNodeInt> stack = new Stack<TreeNodeInt>();
while (stack.Count > 0 || node != null)
{
//while there's a left child, keep going left
if (node != null)
{
stack.Push(node);
node = node.left;
}
//if there's no more left, process current node and then right side
else
{
node = stack.Pop();
list.Add(node.data);
node = node.right;
}
}
}
private void PreOrderIteractive(TreeNodeInt node)
{
Stack<TreeNodeInt> stack = new Stack<TreeNodeInt>();
stack.Push(node);
while (stack.Count > 0)
{
node = stack.Pop();
//process node
//add right child
if (node.right != null) stack.Push(node.right);
//add left child
if (node.left != null) stack.Push(node.left);
}
}
private void InOrderRecursive(TreeNodeInt node, List<int> list)
{
if (node == null)
{
return;
}
//process left child
InOrderRecursive(node.left, list);
//process self
list.Add(node.data);
//process right child
InOrderRecursive(node.right, list);
}
//http://www.geeksforgeeks.org/inorder-tree-traversal-without-recursion-and-without-stack/
private void InOrderIteractiveNoStack(TreeNodeInt current, List<int> list)
{
if (current == null)
{
return;
}
TreeNodeInt predecessor = null;
while (current != null)
{
//if there's no left child, process node and move right
if (current.left == null)
{
list.Add(current.data);
current = current.right;
}
else
{
//there's a left node
//find the inorder predecessor of current
predecessor = current.left;
while (predecessor.right != null && predecessor.right != current)
predecessor = predecessor.right;
// Make current as right child of its inorder predecessor
if (predecessor.right == null)
{
//we can now move to the left side of the tree because prodecessor.right hold a referent to current
//and at some point we'll process predecessor and the next after that is current
predecessor.right = current;
current = current.left;
}
else
{
//Revert the changes made in if part to restore the original
//tree i.e., fix the right child of predecssor
predecessor.right = null;
list.Add(current.data);
current = current.right;
}
}
}
}