public void TestAdd()
{
var bst = new MyBinarySearchTree <int>(50);
Assert.IsNotNull(bst.RootNode);
Assert.AreEqual(50, (int)bst.RootNode.Data, "Root node is not the expected value 50. Instead, its value is {0}", bst.RootNode.Data);
//try to add a value already there; should get back the same node
var expectedRootNode = bst.AddNode(50);
Assert.ReferenceEquals(expectedRootNode, bst.RootNode);
var fortyNode = bst.AddNode(40);
var rootNode = bst.RootNode;
Assert.IsNotNull(rootNode.LeftNode, "Root's left node is null when it should not be. Node 40 added incorrectly");
Assert.IsNull(rootNode.RightNode, "Root's right node is not null when it should be. Node 40 added incorrectly");
Assert.IsTrue(bst.IsDataPresent(40), "Could not find added node 40");
Assert.AreEqual(2, bst.Count, $"Expected count 2. Actual count is {bst.Count}");
var sixtyNode = bst.AddNode(60);
Assert.IsNotNull(rootNode.RightNode, "Root's right node is null when it should not be. Node 60 added incorrectly");
Assert.IsTrue(bst.IsDataPresent(60), "Could not find added node 60");
Assert.AreEqual(3, bst.Count, $"Expected count 3. Actual count is {bst.Count}");
//add another "greater than" node, to the right of 60
var seventyNode = bst.AddNode(70);
Assert.IsNotNull(rootNode.RightNode.RightNode, "Right node of root's right node is null when it should not be. Node 70 added incorrectly");
//add a node on the left of the root's right node
var fiftyFiveNode = bst.AddNode(55);
Assert.IsNotNull(rootNode.RightNode.LeftNode, "Left node of root's right is null when it should not be. Node 55 added incorrectly");
//add a node to the right of the root's left node
var fortyFiveNode = bst.AddNode(45);
Assert.IsNotNull(rootNode.LeftNode.RightNode, "Right node of root's left is null when it should not be. Node 45 added incorrectly");
//add a node to the left of the root's left node
var thirtyFiveNode = bst.AddNode(35);
Assert.IsNotNull(rootNode.LeftNode.LeftNode, "Left node of root's left is null when it should not be. Node 35 added incorrectly");
//try to add a null node
var bst2 = new MyBinarySearchTree <String>("hello");
Assert.ThrowsException <ArgumentNullException>(() => bst2.AddNode(null));
}
public void TestCount()
{
//test that count is one after initialization
var bst = new MyBinarySearchTree <int>(50);
Assert.AreEqual(1, bst.Count);
//test that count is still one when adding a node that's already there
bst.AddNode(50);
Assert.AreEqual(1, bst.Count);
//test that count is 2 after adding a second node
bst.AddNode(40);
Assert.AreEqual(2, bst.Count);
//test that count is back to 1 after deleting a single node
bst.DeleteNode(40);
Assert.AreEqual(1, bst.Count);
//test that count is still the same after trying to delete a non-existent node
bst.DeleteNode(40);
Assert.AreEqual(1, bst.Count);
}
public void TestIsDataPresent()
{
var bst = new MyBinarySearchTree <int>(50);
Assert.IsTrue(bst.IsDataPresent(50), "Could not find root node.");
bst.AddNode(40);
Assert.IsTrue(bst.IsDataPresent(40), "Could not find added node 40");
Assert.IsFalse(bst.IsDataPresent(1), "Found a node that isn't there.");
var bst2 = new MyBinarySearchTree <String>("hello");
bst2.AddNode("world");
Assert.ThrowsException <ArgumentNullException>(() => bst2.IsDataPresent(null));
}
public void TestDeleteNode()
{
Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
Debug.AutoFlush = true;
var bst = new MyBinarySearchTree <int>(50);
bst.AddNode(60);
bst.AddNode(40);
bst.AddNode(70);
bst.AddNode(80);
bst.AddNode(75);
bst.AddNode(90);
bst.AddNode(73);
bst.AddNode(74);
bst.AddNode(85);
bst.AddNode(82);
bst.AddNode(87);
bst.AddNode(100);
bst.AddNode(110);
bst.AddNode(55);
bst.AddNode(53);
bst.AddNode(45);
bst.AddNode(30);
bst.AddNode(35);
bst.AddNode(25);
bst.AddNode(31);
/* we should now have a binary tree that looks like this:
* 50
* 40 60
* 30 45 55 70
* 25 35 53 80
* 31 75 90
* 73 85 100
* 74 82 87 110
*
* We need to try to delete:
* 1) A leaf node that is its parent's right node (45)
* 1a) A leaf node that is its parent's left node (82)
* 2) A node with one right node. Deleted node is the parent's right node (100)
* 2a) A node with one right node. Deleted node is the parent's left node (75)
* 3) A node with one left node. Deleted node is the parent's right node (add 86, then delete 87)
* 3a) A node with one left node. Deleted node is the parent's left node (75)
* 4) A node with both right and left nodes. Deleted node is the parent's right node (90)
* 4a) A node with both right and left nodes. Deleted node is the parent's left node (30)
* 5) A value that's not in the tree
* 6) null
*
*/
Debug.WriteLine(bst.ToString());
//1) Leaf node that is the right node of its parent
int dataToDelete = 45;
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
var deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(deletedNode.Data, dataToDelete);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
Debug.WriteLine(bst.ToString());
//1a) Leaf node on the left side
dataToDelete = 82;
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(deletedNode.Data, dataToDelete);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
Debug.WriteLine(bst.ToString());
//2) node with one right node, and the deleted node is the parent's right node
dataToDelete = 100;
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(deletedNode.Data, dataToDelete);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
var parentOfDeletedNode = bst.RootNode.RightNode.RightNode.RightNode.RightNode;
//check to see if the child of the deleted node is now in the deleted node's place
Assert.AreEqual(110, parentOfDeletedNode.RightNode.Data);
Debug.WriteLine(bst.ToString());
//2a) node with one right node, and the deleted node is the parent's left node
dataToDelete = 73;
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(deletedNode.Data, dataToDelete);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
parentOfDeletedNode = bst.RootNode.RightNode.RightNode.RightNode.LeftNode;
//check to see if the child of the deleted node is now in the deleted node's place
Assert.AreEqual(74, parentOfDeletedNode.LeftNode.Data);
Debug.WriteLine(bst.ToString());
//3) node with one left node, and the deleted node is the parent's right node
dataToDelete = 87;
bst.AddNode(86);
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(deletedNode.Data, dataToDelete);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
parentOfDeletedNode = bst.RootNode.RightNode.RightNode.RightNode.RightNode.LeftNode;
//check to see if the child of the deleted node is now in the deleted node's place
Assert.AreEqual(parentOfDeletedNode.RightNode.Data, 86);
Debug.WriteLine(bst.ToString());
//3a) node with one left node, and the deleted node is the parent's left node
dataToDelete = 75;
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(deletedNode.Data, dataToDelete);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
parentOfDeletedNode = bst.RootNode.RightNode.RightNode.RightNode;
//check to see if the child of the deleted node is now in the deleted node's place
Assert.AreEqual(74, parentOfDeletedNode.LeftNode.Data);
Debug.WriteLine(bst.ToString());
//4) node with both right and left child nodes. Deleted node is parent's right node
dataToDelete = 90;
var newValueOfDeletedNode = 110;
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(newValueOfDeletedNode, deletedNode.Data);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
parentOfDeletedNode = bst.RootNode.RightNode.RightNode.RightNode;
//check to see if the child of the deleted node is now in the deleted node's place
Assert.AreEqual(newValueOfDeletedNode, parentOfDeletedNode.RightNode.Data);
Debug.WriteLine(bst.ToString());
//4a) node with both right and left child nodes. Deleted node is parent's left node
dataToDelete = 30;
newValueOfDeletedNode = 31;
Assert.IsTrue(bst.IsDataPresent(dataToDelete), $"Can't test delete of {dataToDelete}, because it wasn't added properly.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNotNull(deletedNode, $"DeleteNode({dataToDelete}) returned a null node.");
Assert.AreEqual(newValueOfDeletedNode, deletedNode.Data);
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"We deleted the node with data of {dataToDelete}, but it's still in the BST.");
parentOfDeletedNode = bst.RootNode.LeftNode;
//check to see if the child of the deleted node is now in the deleted node's place
Assert.AreEqual(newValueOfDeletedNode, parentOfDeletedNode.LeftNode.Data);
//5) a node that's not there
dataToDelete = 1000;
Assert.IsFalse(bst.IsDataPresent(dataToDelete), $"The node with value {dataToDelete} was unexpectedly found.");
deletedNode = bst.DeleteNode(dataToDelete);
Assert.IsNull(deletedNode, "We tried to delete a non-existent node, but it still returned a node");
//6) try to delete a node with value null
var bst2 = new MyBinarySearchTree <String>("five");
bst2.AddNode("six");
var ex = Assert.ThrowsException <ArgumentNullException>(() => bst2.DeleteNode(null));
}