public TreeNode(string name, int value)
{
LeftNode = null;
RightNode = null;
NodeValue = value;
NodeName = name;
}
public void Test_CreatingTreeNode_WithoutExtraData()
{
var node = new TreeNode<int>();
Assert.AreEqual(node.Data, default(int));
Assert.AreEqual(node.SubTrees, null);
Assert.AreEqual(node.Level, 0UL);
}
public void TestAdd()
{
LoopBinarySearchTree<int> tree = new LoopBinarySearchTree<int>();
TreeNode<int> node1 = new TreeNode<int>(1);
TreeNode<int> node2 = new TreeNode<int>(2);
TreeNode<int> node3 = new TreeNode<int>(3);
TreeNode<int> node4 = new TreeNode<int>(4);
tree.Add(node4.Value);
tree.Add(node2.Value);
tree.Add(node3.Value);
tree.Add(node1.Value);
TreeNode<int> node5 = new TreeNode<int>(5);
TreeNode<int> node6 = new TreeNode<int>(6);
TreeNode<int> node7 = new TreeNode<int>(7);
TreeNode<int> node8 = new TreeNode<int>(8);
tree.Add(node6.Value);
tree.Add(node5.Value);
tree.Add(node8.Value);
tree.Add(node7.Value);
TreeNode<int> testNode = tree.FindNode(node2.Value);
Assert.IsNotNull(testNode, "Couldn't find test node");
Assert.AreEqual(testNode.Value.CompareTo(node2.Value), 0, "Test node does not match value");
Assert.IsNotNull(testNode.LeftNode, "LeftNode is null");
Assert.IsNotNull(testNode.RightNode, "Right node is null");
TreeNode<int> leftNode = testNode.LeftNode;
TreeNode<int> rightNode = testNode.RightNode;
Assert.AreEqual(leftNode.Value.CompareTo(node1.Value), 0, "left node does not match expected value");
Assert.AreEqual(rightNode.Value.CompareTo(node3.Value), 0, "right node does not match expected value");
Assert.AreEqual(leftNode.ParentNode.Value.CompareTo(node2.Value), 0);
Assert.AreEqual(rightNode.ParentNode.Value.CompareTo(node2.Value), 0);
testNode = tree.FindNode(node6.Value);
Assert.IsNotNull(testNode, "Couldn't find test node");
Assert.AreEqual(testNode.Value.CompareTo(node6.Value), 0, "Test node does not match value");
Assert.IsNotNull(testNode.LeftNode, "LeftNode is null");
Assert.IsNotNull(testNode.RightNode, "Right node is null");
leftNode = testNode.LeftNode;
rightNode = testNode.RightNode;
Assert.AreEqual(leftNode.Value.CompareTo(node5.Value), 0, "left node does not match expected value");
Assert.AreEqual(rightNode.Value.CompareTo(node8.Value), 0, "right node does not match expected value");
Assert.AreEqual(leftNode.ParentNode.Value.CompareTo(node6.Value), 0);
Assert.AreEqual(rightNode.ParentNode.Value.CompareTo(node6.Value), 0);
}
private static TreeNode ConstructBinaryTreeWithArray(int[] arr, int l, int r)
{
if (l > r)
{
return null;
}
int mid = (l + r) / 2;
TreeNode root = new TreeNode(arr[mid]);
root.left = ConstructBinaryTreeWithArray(arr, l, mid - 1);
root.right = ConstructBinaryTreeWithArray(arr, mid + 1, r);
return root;
}
public void Test_Enumerator_WithoutSubTrees()
{
var node = new TreeNode<int>(5) {SubTrees = new NodeList<int>(2)};
node.SubTrees = null;
INode<int> onlyOneNode = null;
foreach (var treeNode in ((IEnumerable)node))
{
onlyOneNode = treeNode as INode<int>;
}
Assert.AreNotEqual(onlyOneNode, null);
Assert.AreEqual(onlyOneNode.Data, 5);
}
public void Test_Enumerator_WithSubTrees()
{
var node = new TreeNode<int>(5) {SubTrees = new NodeList<int>(2)};
node.SubTrees[0] = new BinaryTreeNode<int>(70);
node.SubTrees[1] = new BinaryTreeNode<int>(50);
INode<int> a = null;
foreach (var node1 in ((IEnumerable) node))
{
a = node1 as INode<int>;
break;
}
Assert.AreNotEqual(a, null);
Assert.AreEqual(a.Data, 5);
}
public TreeNode AddNode(string name, int value)
{
TreeNode node = new TreeNode(name, value);
if (Root == null)
{
Root = node;
nodesCount++;
}
else
{
Insert(node, ref Root);
}
return node;
}
public void Test_Enumirator_WithZeroSubtrees()
{
var node = new TreeNode<int>(5);
var node2 = new TreeNode<int>(4);
var firstTree = new NodeList<int>(1);
firstTree[0] = node2;
var nl = new NodeList<int>(0);
node2.SubTrees = nl;
node.SubTrees = firstTree;
INode<int> expectedNode = null;
foreach (var treeNode in node)
{
expectedNode = treeNode;
}
Assert.AreNotEqual(expectedNode, null);
Assert.AreEqual(expectedNode.Data, 4);
}
private void Insert(TreeNode node, ref TreeNode tree)
{
if (tree == null)
{
tree = node;
nodesCount++;
}
else
{
if(node.NodeValue < tree.NodeValue)
{
Insert(node, ref tree.LeftNode);
}
else if (node.NodeValue > tree.NodeValue)
{
Insert(node, ref tree.RightNode);
}
}
}
public void BFSTreeWithLevel(TreeNode root)
{
Queue<TreeNode> q = new Queue<TreeNode>();
Queue<TreeNode> q1 = new Queue<TreeNode>();
q.Enqueue(root);
int level = 0;
while (q.Any() || q1.Any())
{
TreeNode cur;
while (q.Any())
{
cur = q.Dequeue();
Console.WriteLine(cur.val);
if (cur.left != null)
{
q1.Enqueue(cur.left);
}
if (cur.right != null)
{
q1.Enqueue(cur.right);
}
}
Console.WriteLine("--------------");
while (q1.Any())
{
cur = q1.Dequeue();
Console.WriteLine(cur.val);
if (cur.left != null)
{
q.Enqueue(cur.left);
}
if (cur.right != null)
{
q.Enqueue(cur.right);
}
}
Console.WriteLine("--------------");
}
}
public void connect(TreeNode root)
{
if (root == null) return;
Queue<TreeNode> q = new Queue<TreeNode>();
q.Enqueue(root);
//level traverse
while (q.Any())
{
int count = q.Count;
while (count > 0)
{
TreeNode temp = q.Dequeue();
if (count == 1)
{
//root.next = null;
}
else
{
//root.left.next = q.Peek();
}
if (temp.left != null)
{
q.Enqueue(temp.left);
}
if (temp.right != null)
{
q.Enqueue(temp.right);
}
count--;
}
}
}
public void Test_CreatingTreeNode_WithData()
{
var node = new TreeNode<int>(5);
Assert.AreEqual(node.Data, 5);
}
public void LoopedPostOrderTraversalTest()
{
LoopBinarySearchTree<int> tree = new LoopBinarySearchTree<int>();
TreeNode<int> node1 = new TreeNode<int>(1);
TreeNode<int> node2 = new TreeNode<int>(2);
TreeNode<int> node3 = new TreeNode<int>(3);
TreeNode<int> node4 = new TreeNode<int>(4);
tree.Add(node4.Value);
tree.Add(node2.Value);
tree.Add(node3.Value);
tree.Add(node1.Value);
TreeNode<int> node5 = new TreeNode<int>(5);
TreeNode<int> node6 = new TreeNode<int>(6);
TreeNode<int> node7 = new TreeNode<int>(7);
TreeNode<int> node8 = new TreeNode<int>(8);
tree.Add(node6.Value);
tree.Add(node5.Value);
tree.Add(node8.Value);
tree.Add(node7.Value);
TreeNode<int>[] nodeArray = new TreeNode<int>[tree.Count];
int index = 0;
nodeArray[index] = node1;
index++;
nodeArray[index] = node3;
index++;
nodeArray[index] = node2;
index++;
nodeArray[index] = node5;
index++;
nodeArray[index] = node7;
index++;
nodeArray[index] = node8;
index++;
nodeArray[index] = node6;
index++;
nodeArray[index] = node4;
IEnumerator<int> enumerator = tree.PostOrderTraversal();
for (index = 0; index < tree.Count; index++)
{
enumerator.MoveNext();
int nextNode = enumerator.Current;
Assert.AreEqual(nodeArray[index].Value.CompareTo(nextNode), 0, string.Format("Expected {0} Actual {1}", nodeArray[index].Value, nextNode));
}
}
private int IsBalancedHelper(TreeNode root)
{
if (root == null)
{
return 0;
}
int lHeight = IsBalancedHelper(root.left) + 1;
int rHeight = IsBalancedHelper(root.right) + 1;
int max = Math.Max(lHeight, rHeight);
int min = Math.Min(lHeight, rHeight);
if (max - min > 1)
{
balanced = false;
}
return max;
}
public List<int> PostOrderTraverse(TreeNode root)
{
LinkedList<int> list = new LinkedList<int>();
if (root == null)
{
return list.ToList();
}
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.Push(root);
while (stack.Any())
{
TreeNode cur = stack.Pop();
list.AddFirst(cur.val);
if (cur.left != null)
{
stack.Push(cur.left);
}
if (cur.right != null)
{
stack.Push(cur.right);
}
}
return list.ToList();
}
public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q)
{
if (root == null || q == null || p == null)
{
return null;
}
//right subtree
if (Math.Min(p.val, q.val) > root.val)
{
return LowestCommonAncestor(root.right, p, q);
}
//left subtree
else if (Math.Max(p.val, q.val) < root.val)
{
return LowestCommonAncestor(root.left, p, q);
}
else
{
return root;
}
}
public bool IsBalanced(TreeNode root)
{
if (root == null)
{
return true;
}
IsBalancedHelper(root);
return balanced;
}
TreeNode(TreeNode left, TreeNode right, int item)
{
this.next = new Next();
this.next.left = left;
this.next.right = right;
this.item = item;
}
private LoopBinarySearchTree<int> ConstructTree()
{
LoopBinarySearchTree<int> tree = new LoopBinarySearchTree<int>();
TreeNode<int> node1 = new TreeNode<int>(1);
TreeNode<int> node2 = new TreeNode<int>(2);
TreeNode<int> node3 = new TreeNode<int>(3);
TreeNode<int> node4 = new TreeNode<int>(4);
tree.Add(node4.Value);
tree.Add(node2.Value);
tree.Add(node3.Value);
tree.Add(node1.Value);
TreeNode<int> node5 = new TreeNode<int>(5);
TreeNode<int> node6 = new TreeNode<int>(6);
TreeNode<int> node7 = new TreeNode<int>(7);
TreeNode<int> node8 = new TreeNode<int>(8);
tree.Add(node6.Value);
tree.Add(node5.Value);
tree.Add(node8.Value);
tree.Add(node7.Value);
return tree;
}
public BinaryTree()
{
Root = null;
nodesCount = 0;
}
