public void AddEmpty()
{
var tree = new aBST(0);
Assert.True(tree.AddKey(15) == 0);
Assert.True(tree.FindKeyIndex(15) == 0);
Assert.True(tree.FindKeyIndex(11) == null);
}
public void TestFind_4()
{
aBST abst = new aBST(2);
abst.AddKey(16);
Assert.AreEqual(-1, abst.FindKeyIndex(10));
Assert.AreEqual(-2, abst.FindKeyIndex(18));
abst.AddKey(18);
Assert.AreEqual(2, abst.FindKeyIndex(18));
Assert.AreEqual(-6, abst.FindKeyIndex(20));
}
public void FindKeyIndex_If_Tree_is_Empty()
{
aBST testTree = new aBST(3);
int? Slot = testTree.FindKeyIndex(4);
int? expectedSlot = null;
Assert.IsTrue(testTree.Tree.Length == 15);
Assert.AreEqual(expectedSlot, Slot);
}
public void Add()
{
var tree = new aBST(2);
Assert.True(tree.AddKey(15) == 0);
Assert.True(tree.AddKey(10) == 1);
Assert.True(tree.AddKey(20) == 2);
Assert.True(tree.AddKey(12) == 4);
Assert.True(tree.AddKey(17) == 5);
Assert.True(tree.AddKey(11) == -1);
Assert.True(tree.AddKey(10) == 1);
Assert.True(tree.AddKey(15) == 0);
Assert.True(tree.AddKey(20) == 2);
Assert.True(tree.AddKey(12) == 4);
Assert.True(tree.AddKey(17) == 5);
Assert.True(tree.FindKeyIndex(15) == 0);
Assert.True(tree.FindKeyIndex(11) == null);
Assert.True(tree.FindKeyIndex(5) == -3);
}
public void FindKeyIndex_If_Tree_Has_Tree_Only()
{
aBST testTree = new aBST(3);
int index = testTree.AddKey(4);
int? index2 = testTree.FindKeyIndex(2);
int expectedIndex = 0;
int? expectedIndex2 = -1;
Assert.IsTrue(testTree.Tree.Length == 15);
Assert.IsTrue(testTree.Tree[0] == 4);
Assert.IsTrue(testTree.Tree[1] == null);
Assert.AreEqual(expectedIndex, index);
Assert.AreEqual(expectedIndex2, index2);
}
public void FindKeyIndexTest()
{
aBST aBST = new aBST(3);
int[] ff = new int[10] {
25, 31, 37, 43, 50, 55, 62, 75, 84, 92
};
foreach (int aa in ff)
{
aBST.AddKey(aa);
}
if (aBST.FindKeyIndex(50) == -1)
{
Assert.Fail();
}
}
public void TestFind_3()
{
aBST abst = GetTree_1();
int b1 = abst.AddKey(19);
int b2 = abst.AddKey(18);
int b3 = abst.AddKey(17);
Assert.AreEqual(11, b1);
Assert.AreEqual(23, b2);
Assert.AreEqual(-1, b3);
Assert.AreEqual(-24, abst.FindKeyIndex(20));
Assert.AreEqual(0, abst.FindKeyIndex(16));
Assert.AreEqual(5, abst.FindKeyIndex(22));
Assert.AreEqual(11, abst.FindKeyIndex(19));
Assert.AreEqual(23, abst.FindKeyIndex(18));
Assert.AreEqual(null, abst.FindKeyIndex(17));
}
public void aBSTTest()
{
aBST aBST = new aBST(3);
if (aBST.AddKey(50) == -1)
{
Assert.Fail();
}
if (aBST.FindKeyIndex(50) != 0)
{
Assert.Fail();
}
if (aBST.AddKey(25) == -1)
{
Assert.Fail();
}
if (aBST.FindKeyIndex(25) != 1)
{
Assert.Fail();
}
if (aBST.AddKey(75) == -1)
{
Assert.Fail();
}
if (aBST.AddKey(37) == -1)
{
Assert.Fail();
}
if (aBST.AddKey(62) == -1)
{
Assert.Fail();
}
if (aBST.AddKey(84) == -1)
{
Assert.Fail();
}
if (aBST.AddKey(31) == -1)
{
Assert.Fail();
}
if (aBST.AddKey(43) == -1)
{
Assert.Fail();
}
if (aBST.AddKey(55) == -1)
{
Assert.Fail();
}
if (aBST.AddKey(92) == -1)
{
Assert.Fail();
}
if (aBST.Tree[3] != null)
{
Assert.Fail();
}
if (aBST.FindKeyIndex(92) != 14)
{
Assert.Fail();
}
}
public void FindKey_If_3_Level_Tree_has_Empty_4_Level()
{
aBST testTree = new aBST(3);
int index1 = testTree.AddKey(8);
int index2 = testTree.AddKey(4);
int index3 = testTree.AddKey(12);
int index4 = testTree.AddKey(2);
int index5 = testTree.AddKey(6);
int index6 = testTree.AddKey(10);
int index7 = testTree.AddKey(14);
int?index8 = testTree.FindKeyIndex(1);
int?index9 = testTree.FindKeyIndex(3);
int?index10 = testTree.FindKeyIndex(5);
int?index11 = testTree.FindKeyIndex(7);
int?index12 = testTree.FindKeyIndex(9);
int?index13 = testTree.FindKeyIndex(11);
int?index14 = testTree.FindKeyIndex(13);
int?index15 = testTree.FindKeyIndex(15);
int expectedAddedIndex1 = 0;
int expectedAddedIndex2 = 1;
int expectedAddedIndex3 = 2;
int expectedAddedIndex4 = 3;
int expectedAddedIndex5 = 4;
int expectedAddedIndex6 = 5;
int expectedAddedIndex7 = 6;
int expectedAddedIndex8 = -7;
int expectedAddedIndex9 = -8;
int expectedAddedIndex10 = -9;
int expectedAddedIndex11 = -10;
int expectedAddedIndex12 = -11;
int expectedAddedIndex13 = -12;
int expectedAddedIndex14 = -13;
int expectedAddedIndex15 = -14;
Assert.IsTrue(testTree.Tree.Length == 15);
Assert.IsTrue(testTree.Tree[0] == 8);
Assert.IsTrue(testTree.Tree[1] == 4);
Assert.IsTrue(testTree.Tree[2] == 12);
Assert.IsTrue(testTree.Tree[3] == 2);
Assert.IsTrue(testTree.Tree[4] == 6);
Assert.IsTrue(testTree.Tree[5] == 10);
Assert.IsTrue(testTree.Tree[6] == 14);
Assert.IsNull(testTree.Tree[7]);
Assert.IsNull(testTree.Tree[8]);
Assert.IsNull(testTree.Tree[9]);
Assert.IsNull(testTree.Tree[10]);
Assert.IsNull(testTree.Tree[11]);
Assert.IsNull(testTree.Tree[12]);
Assert.IsNull(testTree.Tree[13]);
Assert.IsNull(testTree.Tree[14]);
Assert.AreEqual(expectedAddedIndex1, index1);
Assert.AreEqual(expectedAddedIndex2, index2);
Assert.AreEqual(expectedAddedIndex3, index3);
Assert.AreEqual(expectedAddedIndex4, index4);
Assert.AreEqual(expectedAddedIndex5, index5);
Assert.AreEqual(expectedAddedIndex6, index6);
Assert.AreEqual(expectedAddedIndex7, index7);
Assert.AreEqual(expectedAddedIndex8, index8);
Assert.AreEqual(expectedAddedIndex9, index9);
Assert.AreEqual(expectedAddedIndex10, index10);
Assert.AreEqual(expectedAddedIndex11, index11);
Assert.AreEqual(expectedAddedIndex12, index12);
Assert.AreEqual(expectedAddedIndex13, index13);
Assert.AreEqual(expectedAddedIndex14, index14);
Assert.AreEqual(expectedAddedIndex15, index15);
}
public void TestFindKeyIndex()
{
Assert.AreEqual(0, _tree.FindKeyIndex(50));
Assert.AreEqual(1, _tree.FindKeyIndex(25));
Assert.AreEqual(2, _tree.FindKeyIndex(75));
Assert.AreEqual(4, _tree.FindKeyIndex(37));
Assert.AreEqual(5, _tree.FindKeyIndex(62));
Assert.AreEqual(6, _tree.FindKeyIndex(84));
Assert.AreEqual(9, _tree.FindKeyIndex(31));
Assert.AreEqual(10, _tree.FindKeyIndex(43));
Assert.AreEqual(11, _tree.FindKeyIndex(55));
Assert.AreEqual(14, _tree.FindKeyIndex(92));
Assert.AreEqual(-3, _tree.FindKeyIndex(24));
Assert.AreEqual(-12, _tree.FindKeyIndex(63));
Assert.AreEqual(-13, _tree.FindKeyIndex(83));
}
public void TestOverAll_1()
{
aBST abst = new aBST(3);
Assert.AreEqual(0, abst.AddKey(16));
Assert.AreEqual(1, abst.AddKey(4));
Assert.AreEqual(2, abst.AddKey(24));
Assert.AreEqual(3, abst.AddKey(-2));
Assert.AreEqual(4, abst.AddKey(12));
Assert.AreEqual(5, abst.AddKey(20));
Assert.AreEqual(6, abst.AddKey(28));
Assert.AreEqual(7, abst.AddKey(-3));
Assert.AreEqual(8, abst.AddKey(-1));
Assert.AreEqual(9, abst.AddKey(8));
Assert.AreEqual(10, abst.AddKey(14));
Assert.AreEqual(11, abst.AddKey(18));
Assert.AreEqual(12, abst.AddKey(22));
Assert.AreEqual(13, abst.AddKey(26));
Assert.AreEqual(14, abst.AddKey(30));
Assert.AreEqual(14, abst.AddKey(30));
Assert.AreEqual(-1, abst.AddKey(32));
Assert.AreEqual(0, abst.FindKeyIndex(16));
Assert.AreEqual(1, abst.FindKeyIndex(4));
Assert.AreEqual(2, abst.FindKeyIndex(24));
Assert.AreEqual(3, abst.FindKeyIndex(-2));
Assert.AreEqual(4, abst.FindKeyIndex(12));
Assert.AreEqual(5, abst.FindKeyIndex(20));
Assert.AreEqual(6, abst.FindKeyIndex(28));
Assert.AreEqual(7, abst.FindKeyIndex(-3));
Assert.AreEqual(8, abst.FindKeyIndex(-1));
Assert.AreEqual(9, abst.FindKeyIndex(8));
Assert.AreEqual(10, abst.FindKeyIndex(14));
Assert.AreEqual(11, abst.FindKeyIndex(18));
Assert.AreEqual(12, abst.FindKeyIndex(22));
Assert.AreEqual(13, abst.FindKeyIndex(26));
Assert.AreEqual(14, abst.FindKeyIndex(30));
abst.Tree[14] = null;
Assert.AreEqual(-14, abst.FindKeyIndex(30));
Assert.AreEqual(14, abst.AddKey(30));
Assert.AreEqual(14, abst.FindKeyIndex(30));
}
public void TestFind_2()
{
aBST abst = GetTree_1();
Assert.AreEqual(0, abst.FindKeyIndex(16));
Assert.AreEqual(1, abst.FindKeyIndex(8));
Assert.AreEqual(2, abst.FindKeyIndex(24));
Assert.AreEqual(3, abst.FindKeyIndex(4));
Assert.AreEqual(4, abst.FindKeyIndex(12));
Assert.AreEqual(5, abst.FindKeyIndex(22));
Assert.AreEqual(6, abst.FindKeyIndex(28));
Assert.AreEqual(7, abst.FindKeyIndex(-1));
Assert.AreEqual(9, abst.FindKeyIndex(11));
Assert.AreEqual(10, abst.FindKeyIndex(13));
Assert.AreEqual(12, abst.FindKeyIndex(23));
Assert.AreEqual(4, abst.FindKeyIndex(12));
Assert.AreEqual(0, abst.FindKeyIndex(16));
Assert.AreEqual(1, abst.FindKeyIndex(8));
Assert.AreEqual(2, abst.FindKeyIndex(24));
Assert.AreEqual(3, abst.FindKeyIndex(4));
Assert.AreEqual(4, abst.FindKeyIndex(12));
Assert.AreEqual(5, abst.FindKeyIndex(22));
Assert.AreEqual(6, abst.FindKeyIndex(28));
Assert.AreEqual(7, abst.FindKeyIndex(-1));
Assert.AreEqual(9, abst.FindKeyIndex(11));
Assert.AreEqual(10, abst.FindKeyIndex(13));
Assert.AreEqual(12, abst.FindKeyIndex(23));
}
public void TestFind_1()
{
aBST abst = GetTree_1();
Assert.AreEqual(10, abst.FindKeyIndex(13));
}
