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