private static IBinaryExpressionTree BuildPrefixTree(this Queue <char> expressionValues, int identation)
{
if (expressionValues.Count <= 0)
{
return(null);
}
char value = expressionValues.Dequeue();
if (!value.IsOperator())
{
return(new BinaryExpressionTree(new Node(value, identation, true)));
}
else
{
BinaryExpressionTree tree = new BinaryExpressionTree(
new Node(value, identation++, false),
BuildPrefixTree(expressionValues, identation),
((char)Operators.Negation).Equals(value)
? null
: BuildPrefixTree(expressionValues, identation)
);
return(tree);
}
}
public void GetLeafs_Should_Return_List_Of_All_The_Nodes_Without_Parents()
{
IBinaryExpressionTree tree = new BinaryExpressionTree(VALID_ROOT_NODE, VALID_LEFT_CHILD, VALID_RIGHT_CHILD);
var leafs = tree.GetLeafs();
leafs.Should().ContainInOrder(EXPECTED_LEAFS);
}
public void GetEdges_Should_Return_List_Of_Relations_Between_Parent_And_Child()
{
IBinaryExpressionTree tree = new BinaryExpressionTree(VALID_ROOT_NODE, VALID_LEFT_CHILD, VALID_RIGHT_CHILD);
var edges = tree.GetEdges();
edges.Should().ContainInOrder(EXPECTED_EDGES);
}
public void GetNodes_Should_Return_List_Of_All_Tree_Nodes()
{
IBinaryExpressionTree tree = new BinaryExpressionTree(VALID_ROOT_NODE, VALID_LEFT_CHILD, VALID_RIGHT_CHILD);
var nodes = tree.GetNodes();
nodes.Should().ContainInOrder(EXPECTED_NODES);
}
public void Should_Create_ExpressionTree_With_One_Node_And_Left_Child()
{
IBinaryExpressionTree tree = new BinaryExpressionTree(VALID_ROOT_NODE, VALID_LEFT_CHILD);
tree.CurrentNode.Should().Be(VALID_ROOT_NODE);
tree.LeftChild.Should().Be(VALID_LEFT_CHILD);
tree.LeftChild.Parent.Should().Be(VALID_ROOT_NODE);
}
public void TraversePostOrdered_Should_Return_List_Of_All_The_Nodes_In_Post_Order()
{
IBinaryExpressionTree tree = new BinaryExpressionTree(VALID_ROOT_NODE, VALID_LEFT_CHILD, VALID_RIGHT_CHILD);
var postOrdered = tree.TraversePostOrder();
postOrdered.Should().ContainInOrder(EXPECTED_TRAVERSED_POSTORDERED);
}
public static void UnitTest()
{
Console.WriteLine ("----- Testing BinarySearchTree<int> -----");
Console.Write ("Creating new BinarySearchTree of type <int>...");
BinarySearchTree<int> test = new BinarySearchTree<int> (); d ();
Console.Write ("Adding value 50...");
test.Add (50); d ();
Console.Write ("Adding value 25...");
test.Add (25); d ();
Console.Write ("Adding value 75...");
test.Add (75); d ();
Console.Write ("Checking for correct structure (25/50\\75)...");
Debug.Assert (test.root.value == 50);
Debug.Assert (test.root.nodes[0].value == 25);
Debug.Assert (test.root.nodes[1].value == 75);
d ();
Console.Write ("Checking if BinarySearchTree.Contains(75) works...");
Debug.Assert (test.Contains(75)); d ();
Console.Write ("Testing BinarySearchTree.TraversePre()...");
Debug.Assert( test.TraversePre ((x) => Console.Write (x.value + " ")) == "50 25 75 "); d ();
Console.Write ("Testing BinarySearchTree.TraverseInOrder()...");
Debug.Assert( test.TraverseInOrder ((x) => Console.Write (x.value + " ")) == "25 50 75 "); d ();
Console.Write ("Testing BinarySearchTree.TraversePost()...");
Debug.Assert( test.TraversePost ((x) => Console.Write (x.value + " ")) == "25 75 50 "); d ();
Console.WriteLine ("----- Testing BinarySearchTree<string> -----");
Console.Write ("Creating new BinarySearchTree of type <string> with custom IComparer...");
BinarySearchTree<string> foo = new BinarySearchTree<string> ( new StringComparer() ); d ();
Console.Write ("Adding value Urist McSmashes...");
foo.Add ("Urist McSmashes"); d ();
Console.Write ("Adding value Gordon Freeman...");
foo.Add ("Gordon Freeman"); d ();
Console.Write ("Adding value Winston Smith...");
foo.Add ("Winston Smith"); d ();
Console.Write ("Checking for correct structure (Gordon Freeman/Urist McSmashes\\Winston Smith)...");
Debug.Assert (foo.root.value == "Urist McSmashes");
Debug.Assert (foo.root.nodes[0].value == "Gordon Freeman");
Debug.Assert (foo.root.nodes[1].value == "Winston Smith");
d ();
Console.WriteLine ("----- Testing BinaryExpressionTree -----");
Console.Write ("Creating new BinaryExpressionTree with expression \"5 + 2 * 8 - 6 / 4\"...");
BinaryExpressionTree bar = new BinaryExpressionTree ("5 + 2 * 8 - 6 / 4"); d ();
Console.Write ("Checking for correct structure...");
Debug.Assert( bar.TraverseInOrder ((x) => Console.Write (x.value + " ")) == "4 47 6 45 8 42 2 43 5 ");
Debug.Assert( bar.root.value == 45 ); // -
Debug.Assert( bar.root.nodes[0].value == 47 ); // /
Debug.Assert( bar.root.nodes[0].nodes[0].value == 4 );
Debug.Assert( bar.root.nodes[0].nodes[1].value == 6 );
Debug.Assert( bar.root.nodes[1].value == 43 ); // +
Debug.Assert( bar.root.nodes[1].nodes[1].value == 5 );
Debug.Assert( bar.root.nodes[1].nodes[0].value == 42 ); // *
Debug.Assert( bar.root.nodes[1].nodes[0].nodes[0].value == 8 );
Debug.Assert( bar.root.nodes[1].nodes[0].nodes[1].value == 2 );
d ();
Console.Write ("Checking for correct answer \"5 + 2 * 8 - 6 / 4\" = " + (5.0 + 2.0 * 8.0 - 6.0 / 4.0) + "...");
Debug.Assert (bar.Eval () == (5.0 + 2.0 * 8.0 - 6.0 / 4.0)); d ();
Console.WriteLine ("Everything appears to be in order! Although asserts in C# don't actually end execution so there's no real way for me to know!");
}
public void Should_Build_Valid_TruthTable_With_Passed_Valid_ExpressionTree()
{
var tree = new BinaryExpressionTree(new Node('|', 1),
new BinaryExpressionTree(new Node('|', 2),
new BinaryExpressionTree(new Node(VARIABLE_A, 3, true)),
new BinaryExpressionTree(new Node(VARIABLE_B, 3, true))
),
new BinaryExpressionTree(new Node('|', 2),
new BinaryExpressionTree(new Node(VARIABLE_A, 3, true)),
new BinaryExpressionTree(new Node(VARIABLE_C, 3, true))
)
);
tree.BuildTruthTable(VARIABLE_RESULT).Value.Should().BeEquivalentTo(VALID_TRUTHTABLE_VALUES);
}
public void Should_Create_ExpressionTree_With_One_Node_Only()
{
IBinaryExpressionTree tree = new BinaryExpressionTree(VALID_ROOT_NODE);
tree.CurrentNode.Should().Be(VALID_ROOT_NODE);
}
