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; }