public void LevelOrderTest1()
{
TreeNode root = new TreeNode(1);
root.left = new TreeNode(2);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right = new TreeNode(3);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(7);
IList <IList <int> > expected = new List <IList <int> >()
{
new List <int>()
{
1
}, new List <int>()
{
2, 3
}, new List <int>()
{
4, 5, 6, 7
},
};
var result = new BinaryTreeLevelOrderTraversal().LevelOrder(root);
Assert.AreEqual(expected, result);
}
public void TestIterative()
{
var sol = new BinaryTreeLevelOrderTraversal();
var root = new TreeNode(3)
{
left = new TreeNode(9),
right = new TreeNode(20)
{
left = new TreeNode(15),
right = new TreeNode(7)
}
};
var ret = sol.LevelOrder(root);
IList <IList <int> > expected = new List <IList <int> >();
expected.Add(new List <int>()
{
3
});
expected.Add(new List <int>()
{
9, 20
});
expected.Add(new List <int>()
{
15, 7
});
Utlilitiy.AssertAreEqual(expected, ret);
}
public void IterativeTestWithEmptyTree()
{
BinaryTreeLevelOrderTraversal <int> .TreeNode root = null;
IList <IList <int> > levelorder = BinaryTreeLevelOrderTraversal <int> .IterativeLevelOrder(root);
Assert.Equal(0, levelorder.Count);
}
public void LevelOrderTest()
{
TreeNode root = new TreeNode(3);
root.left = new TreeNode(9);
root.right = new TreeNode(20);
root.right.left = new TreeNode(15);
root.right.right = new TreeNode(7);
IList <IList <int> > expected = new List <IList <int> >()
{
new List <int>()
{
3
}, new List <int>()
{
9, 20
}, new List <int>()
{
15, 7
},
};
var result = new BinaryTreeLevelOrderTraversal().LevelOrder(root);
Assert.AreEqual(expected, result);
}
public void LevelOrderTraversalTestCase2()
{
var tree = new MyBinaryTree(1);
tree.Left = new MyBinaryTree(2);
tree.Left.Left = new MyBinaryTree(3);
tree.Left.Left.Left = new MyBinaryTree(4);
tree.Left.Left.Left.Left = new MyBinaryTree(5);
var result = BinaryTreeLevelOrderTraversal.LevelOrderTraversal(tree);
result[0].Should().ContainInOrder(new List <int> {
1
});
result[1].Should().ContainInOrder(new List <int> {
2
});
result[2].Should().ContainInOrder(new List <int> {
3
});
result[3].Should().ContainInOrder(new List <int> {
4
});
result[4].Should().ContainInOrder(new List <int> {
5
});
}
public void LevelOrderTraversalTestCase1()
{
var tree = new MyBinaryTree(6);
tree.Left = new MyBinaryTree(2);
tree.Left.Left = new MyBinaryTree(1);
tree.Left.Right = new MyBinaryTree(4);
tree.Left.Right.Left = new MyBinaryTree(3);
tree.Left.Right.Right = new MyBinaryTree(5);
tree.Right = new MyBinaryTree(7);
tree.Right.Right = new MyBinaryTree(9);
tree.Right.Right.Left = new MyBinaryTree(8);
var result = BinaryTreeLevelOrderTraversal.LevelOrderTraversal(tree);
result[0].Should().ContainInOrder(new List <int> {
6
});
result[1].Should().ContainInOrder(new List <int> {
2, 7
});
result[2].Should().ContainInOrder(new List <int> {
1, 4, 9
});
result[3].Should().ContainInOrder(new List <int> {
3, 5, 8
});
}
public void IterativeTestWithThreeLevels()
{
// Arrange
BinaryTreeLevelOrderTraversal <int> .TreeNode root = new BinaryTreeLevelOrderTraversal <int> .TreeNode(3);
root.left = new BinaryTreeLevelOrderTraversal <int> .TreeNode(5);
root.right = new BinaryTreeLevelOrderTraversal <int> .TreeNode(9);
root.right.left = new BinaryTreeLevelOrderTraversal <int> .TreeNode(17);
root.right.right = new BinaryTreeLevelOrderTraversal <int> .TreeNode(20);
IList <IList <int> > levelorder = BinaryTreeLevelOrderTraversal <int> .IterativeLevelOrder(root);
IList <IList <int> > expectList = new List <IList <int> >();
for (int i = 0; i < 3; i++)
{
expectList.Add(new List <int>());
}
expectList[0].Add(3);
expectList[1].Add(5);
expectList[1].Add(9);
expectList[2].Add(17);
expectList[2].Add(20);
// Assert
int index = 0;
Console.WriteLine("Iterative Level Order: ");
foreach (IList <int> level in levelorder)
{
for (int i = 0; i < level.Count; i++)
{
int val = level[i];
Assert.Equal(val, expectList[index][i]);
Console.Write(val + " ");
}
index++;
Console.WriteLine();
}
}
public void binaryTreeLevelOrderTraversalTest()
{
/*
* [
* [3],
* [9,20],
* [15,7]
* ]
*/
var result = BinaryTreeLevelOrderTraversal.LevelOrder(root);
Console.WriteLine("Level Order Traversal: ");
for (int i = 0; i < result.Count; i++)
{
foreach (int node in result[i])
{
Console.Write(node + ", ");
}
Console.WriteLine();
}
}
public void LevelOrderTraversalTestCase3()
{
var tree = new MyBinaryTree(3);
tree.Left = new MyBinaryTree(9);
tree.Right = new MyBinaryTree(20);
tree.Right.Left = new MyBinaryTree(15);
tree.Right.Right = new MyBinaryTree(7);
var result = BinaryTreeLevelOrderTraversal.LevelOrderTraversal(tree);
result[0].Should().ContainInOrder(new List <int> {
3
});
result[1].Should().ContainInOrder(new List <int> {
9, 20
});
result[2].Should().ContainInOrder(new List <int> {
15, 7
});
}
public void ConstructBSTfromLevelOrder()
{
// arrange
char[] array = { 'S', 'E', 'T', 'A', 'R', 'C', 'H', 'M' };
BinaryTreeLevelOrderTraversal <char> .TreeNode root = BinaryTreeLevelOrderTraversal <char> .ReconstructFromLevelOrder(array);
IList <IList <char> > expectChars = new List <IList <char> >();
for (int i = 0; i < 5; i++)
{
expectChars.Add(new List <char>());
}
expectChars[0].Add('S');
expectChars[1].Add('E');
expectChars[1].Add('T');
expectChars[2].Add('A');
expectChars[2].Add('R');
expectChars[3].Add('C');
expectChars[3].Add('H');
expectChars[4].Add('M');
// assert
int index = 0;
Console.WriteLine("Reconstruct tree from Level Order: ");
foreach (IList <char> level in expectChars)
{
for (int i = 0; i < level.Count; i++)
{
char val = level[i];
Assert.Equal(val, expectChars[index][i]);
Console.Write(val + " ");
}
index++;
Console.WriteLine();
}
}
public void BeforeEach()
{
BinaryTreeLevelOrderTraversal = new BinaryTreeLevelOrderTraversal();
}
