public void Print(TreeDSNode root) { TreeDSNode currentNode = null; var queue = new Queue<TreeDSNode>(); queue.Enqueue(root); var stack = new Stack<TreeDSNode>(); while (queue.Count > 0) { currentNode = queue.Dequeue(); stack.Push(currentNode); if (currentNode.isLeftNodeAvailable()) { queue.Enqueue(currentNode.Left); } if (currentNode.isRightNodeAvailable()) { queue.Enqueue(currentNode.Right); } } while (stack.Count > 0) { var nodeToPrint = stack.Pop(); PrintNode(nodeToPrint); } }
private int GetNodesCount(TreeDSNode root, NodeTypeFilter filter) { var currentNode = root; var strictNodesCount = 0; var queue = new Queue <TreeDSNode>(); queue.Enqueue(root); while (queue.Count > 0) { currentNode = queue.Dequeue(); if (filter(currentNode)) { strictNodesCount++; } if (currentNode.isLeftNodeAvailable()) { queue.Enqueue(currentNode.Left); } if (currentNode.isRightNodeAvailable()) { queue.Enqueue(currentNode.Right); } } return(strictNodesCount); }
public void ShouldReturnMaxNodeInNonRecursion() { TreeDSNode rootNode = TreeTestData.GetComplexTreeRootNode(); FindMaxElement findMaxNode = new FindMaxElement(); var maxNode = findMaxNode.UsingNonRecursion(rootNode); Assert.AreEqual(8, maxNode.Value); }
public void ShouldReturnFullNodesCount() { TreeDSNode rootNode = TreeTestData.GetComplexTreeRootNode(); TreeNodesType treeNodesType = new TreeNodesType(); var fullNodesCount = treeNodesType.FullNodesCount(rootNode); Assert.AreEqual(3, fullNodesCount); }
public void ShouldReturnLeafNodesCount() { TreeDSNode rootNode = TreeTestData.GetComplexTreeRootNode(); TreeNodesType treeNodesType = new TreeNodesType(); var leafNodesCount = treeNodesType.LeaftNodesCount(rootNode); Assert.AreEqual(4, leafNodesCount); }
public void ShouldReturnDeepestNode() { TreeDSNode rootNode = TreeTestData.GetComplexTreeRootNode(); DeepestNodeOfTree deepestNodeOfTree = new DeepestNodeOfTree(); var deepestNode = deepestNodeOfTree.Find(rootNode); Assert.AreEqual(8, deepestNode.Value); }
public void ShouldReturnDiameterOfTree() { TreeDSNode rootNode = TreeTestData.GetComplexTreeRootNode(); DiameterOfTree diameterOfTree = new DiameterOfTree(); var diameter = diameterOfTree.Find(rootNode); Assert.AreEqual(6, diameter); }
public void FindShouldReturnMaxSumInLevelOfTree() { TreeDSNode rootNode = TreeTestData.GetComplexTreeRootNode(); MaxSumInLevelOfTree maxSumInLevelOfTree = new MaxSumInLevelOfTree(); var maxSum = maxSumInLevelOfTree.Find(rootNode); Assert.AreEqual(15, maxSum); }
public void ShouldReturnSizeUsingNonRecursion() { TreeDSNode rootNode = TreeTestData.GetSimpleTreeRootNode(); var treeSize = new TreeSize(); var actualSize = treeSize.UsingNonRecursion(rootNode); Assert.AreEqual(6, actualSize); }
public void ShouldReturnHeightUsinrNonRecussion() { TreeDSNode rootNode = TreeTestData.GetComplexTreeRootNode(); IAlgorithm <TreeDSNode, int> heightOfTree = new HeightOfTree(); var height = heightOfTree.UsingNonRecursion(rootNode); Assert.AreEqual(4, height); }
public void ShouldReturnTrueIfTwoTreeStructuresAreSame() { TreeDSNode rootNodeOfFirstTree = TreeTestData.GetComplexTreeRootNode(); TreeDSNode rootNodeOfSecondTree = TreeTestData.GetRootNodeOfComplexTreeWithHighervalue(); var structuralIdentification = new StructuralIdentification(); var structuralIdentificationResult = structuralIdentification.Validate(rootNodeOfFirstTree, rootNodeOfSecondTree); Assert.AreEqual(true, structuralIdentificationResult); }
public void ShouldReturnFalseIfTwoTreeStructuresAreNotIdentical() { TreeDSNode rootNodeOfFirstTree = TreeTestData.GetComplexTreeRootNode(); TreeDSNode rootNodeOfSecondTree = TreeTestData.GetLeftSplayTreeRootNode(); var structuralIdentification = new StructuralIdentification(); var structuralIdentificationResult = structuralIdentification.Validate(rootNodeOfFirstTree, rootNodeOfSecondTree); Assert.AreEqual(false, structuralIdentificationResult); }
public ZigZagTraversal(TreeDSNode rootNode, IConsoleWriter console = null) { this.console = console; if (rootNode == null) { throw new NullReferenceException(); } root = rootNode; }
public void ShouldReturnLeastCommonAncestorWith12Nodes() { var rootNode = TreeTestData.GetComplexTreeRootNodeWith12Nodes(); var nodeWithValue10 = TreeDSNode.Create(10); var nodeWithValue12 = TreeDSNode.Create(12); LeastCommonAncestor leastCommonAncestor = new LeastCommonAncestor(); var actualLCA = leastCommonAncestor.Find(rootNode, nodeWithValue10, nodeWithValue12); Assert.AreEqual(10, actualLCA.Value); }
private void PrintNode(TreeDSNode node) { if (node == null) return; if (console != null) console.WriteLine(node.Value); else System.Console.Out.WriteLine(node.Value); }
public void ShouldPrintTreeNodesInZigZagTraversal() { var expectedOutputs = new List <int>() { 1, 3, 2, 4, 5, 6 }; IConsoleWriter writerMock = MockWriter.GetInstance(expectedOutputs); TreeDSNode rootNode = TreeTestData.GetSimpleTreeRootNode(); ZigZagTraversal zigzagTraversal = new ZigZagTraversal(rootNode, writerMock); zigzagTraversal.Travel(); }
public void ShouldPrintTreeInLevelOrder() { var expectedOutputs = new List <int>() { 1, 2, 3, 4, 5, 6 }; IConsoleWriter writerMock = MockWriter.GetInstance(expectedOutputs); TreeDSNode rootNode = TreeTestData.GetSimpleTreeRootNode(); TreeTraversal tree = new TreeTraversal(rootNode, writerMock); tree.LevelOrderTraversal(); }
// Tree structure (right splay tree) // 1 // 2 // 3 // 4 // 5 // 6 public static TreeDSNode GetRightSplayTreeRootNode() { TreeDSNode nodeWithValue6, root; nodeWithValue6 = TreeDSNode.Create(6); TreeDSNode nodeWithValue5 = new TreeDSNode(5, null, nodeWithValue6); TreeDSNode nodeWithValue4 = new TreeDSNode(4, null, nodeWithValue5); TreeDSNode nodeWithValue3 = new TreeDSNode(3, null, nodeWithValue4); TreeDSNode nodeWithValue2 = new TreeDSNode(2, null, nodeWithValue3); root = new TreeDSNode(1, nodeWithValue2, null); return(root); }
public void ShouldReturnLeastCommonAncestor() { var rootNode = TreeTestData.GetComplexTreeRootNode(); var nodeWithValue4 = TreeDSNode.Create(4); var nodeWithValue5 = TreeDSNode.Create(5); var nodeWithValue3 = TreeDSNode.Create(3); LeastCommonAncestor leastCommonAncestor = new LeastCommonAncestor(); var actualLCA = leastCommonAncestor.Find(rootNode, nodeWithValue4, nodeWithValue5); Assert.AreEqual(2, actualLCA.Value); actualLCA = leastCommonAncestor.Find(rootNode, nodeWithValue4, nodeWithValue3); Assert.AreEqual(1, actualLCA.Value); }
// Tree structure // 1 // 2 3 // 4 5 6 public static TreeDSNode GetSimpleTreeRootNode() { TreeDSNode nodeWithValue4, nodeWithValue6, root; nodeWithValue4 = TreeDSNode.Create(4); var nodeWithValue5 = TreeDSNode.Create(5); nodeWithValue6 = TreeDSNode.Create(6); TreeDSNode nodeWithValue2 = new TreeDSNode(2, nodeWithValue4, nodeWithValue5); TreeDSNode nodeWithValue3 = new TreeDSNode(3, nodeWithValue6, null); root = new TreeDSNode(1, nodeWithValue2, nodeWithValue3); return(root); }
public int Find(TreeDSNode root) { if (root == null) { return(0); } var leftHeight = HeightOfTree(root.Left); var rightHeight = HeightOfTree(root.Right); var leftDiameter = Find(root.Left); var rightDiameter = Find(root.Right); return(Math.Max(1 + leftHeight + rightHeight, Math.Max(leftDiameter, rightDiameter))); }
public TreeDSNode Create(TreeDSNode root) { if (root == null) { return(null); } var tempLeft = root.Left; var tempRight = root.Right; root.Left = Create(root.Right); root.Right = Create(tempLeft); return(root); }
// Tree structure // 1 // 3 2 // 6 5 4 // 8 7 public static TreeDSNode GetRootNodeOfComplexTreeMirror() { TreeDSNode nodeWithValue4, nodeWithValue7, nodeWithValue8, root; nodeWithValue4 = TreeDSNode.Create(4); nodeWithValue7 = TreeDSNode.Create(7); nodeWithValue8 = TreeDSNode.Create(8); var nodeWithValue6 = TreeDSNode.Create(6); var nodeWithValue5 = new TreeDSNode(5, nodeWithValue8, nodeWithValue7); TreeDSNode nodeWithValue2 = new TreeDSNode(2, nodeWithValue5, nodeWithValue4); TreeDSNode nodeWithValue3 = new TreeDSNode(3, null, nodeWithValue6); root = new TreeDSNode(1, nodeWithValue3, nodeWithValue2); return(root); }
// Tree structure // 1 // 2 3 // 4 5 6 // 7 8 public static TreeDSNode GetComplexTreeRootNode() { TreeDSNode nodeWithValue4, nodeWithValue7, nodeWithValue8, root; nodeWithValue4 = TreeDSNode.Create(4); nodeWithValue7 = TreeDSNode.Create(7); nodeWithValue8 = TreeDSNode.Create(8); var nodeWithValue6 = TreeDSNode.Create(6); var nodeWithValue5 = new TreeDSNode(5, nodeWithValue7, nodeWithValue8); TreeDSNode nodeWithValue2 = new TreeDSNode(2, nodeWithValue4, nodeWithValue5); TreeDSNode nodeWithValue3 = new TreeDSNode(3, nodeWithValue6, null); root = new TreeDSNode(1, nodeWithValue2, nodeWithValue3); return(root); }
// Tree structure // 70 // 80 47 // 90 108 99 // 54 77 public static TreeDSNode GetRootNodeOfComplexTreeWithHighervalue() { TreeDSNode nodeWithValue4, nodeWithValue7, nodeWithValue8, nodeWithValue6, root; nodeWithValue4 = TreeDSNode.Create(90); nodeWithValue7 = TreeDSNode.Create(54); nodeWithValue8 = TreeDSNode.Create(77); var nodeWithValue5 = TreeDSNode.Create(108); nodeWithValue6 = new TreeDSNode(99, nodeWithValue7, nodeWithValue8); TreeDSNode nodeWithValue2 = new TreeDSNode(80, nodeWithValue4, nodeWithValue5); TreeDSNode nodeWithValue3 = new TreeDSNode(47, nodeWithValue6, null); root = new TreeDSNode(70, nodeWithValue2, nodeWithValue3); return(root); }
public bool Check(TreeDSNode root, int sum) { if (root == null || root.Value > sum) { return(false); } int remainingSum = sum - root.Value; if (remainingSum == 0) { return(true); } return(Check(root.Left, remainingSum) || Check(root.Right, remainingSum)); }
private void PrintNode(TreeDSNode node) { if (node == null) { return; } if (console != null) { console.WriteLine(node.Value); } else { System.Console.Out.WriteLine(node.Value); } }
public bool Validate(TreeDSNode rootOfFirstTree, TreeDSNode rootOfSecondTree) { if (rootOfFirstTree == null && rootOfSecondTree == null) { return(true); } if (rootOfFirstTree != null && rootOfSecondTree == null) { return(false); } else if (rootOfFirstTree == null && rootOfSecondTree != null) { return(false); } return(Validate(rootOfFirstTree.Left, rootOfSecondTree.Left) && Validate(rootOfFirstTree.Right, rootOfSecondTree.Right)); }
public int HeightOfTree(TreeDSNode root) { int leftHeight = 0, rightHeight = 0; if (root == null) { return(0); } if (root.isLeftNodeAvailable()) { leftHeight = HeightOfTree(root.Left); } if (root.isRightNodeAvailable()) { rightHeight = HeightOfTree(root.Right); } return(leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1); }
public TreeDSNode Find(TreeDSNode root) { TreeDSNode currentNode = null; var queue = new Queue <TreeDSNode>(); queue.Enqueue(root); while (queue.Count > 0) { currentNode = queue.Dequeue(); if (currentNode.isLeftNodeAvailable()) { queue.Enqueue(currentNode.Left); } if (currentNode.isRightNodeAvailable()) { queue.Enqueue(currentNode.Right); } } return(currentNode); }