public void Delete_EntireArray()
{
int[] data = { 5, 2, 6, 3, 1, 4 };
int[] expected = { 1, 2, 3, 4, 5, 6 };
IBinarySearchTree<int> tree = new BinarySearchTree<int>();
foreach (int value in data)
tree.Insert(value);
int[] actualArray = tree.ToArray();
CollectionAssert.AreEqual(expected, actualArray);
Assert.AreEqual(expected.Length, tree.Size);
Assert.IsTrue(tree.Delete(1));
Assert.IsFalse(tree.Find(1));
Assert.IsTrue(tree.Delete(2));
Assert.IsFalse(tree.Find(2));
Assert.IsTrue(tree.Delete(3));
Assert.IsFalse(tree.Find(3));
Assert.IsTrue(tree.Delete(4));
Assert.IsFalse(tree.Find(4));
Assert.IsTrue(tree.Delete(5));
Assert.IsFalse(tree.Find(5));
Assert.IsTrue(tree.Delete(6));
Assert.IsFalse(tree.Find(6));
Assert.AreEqual(0, tree.Size);
}
public void Delete_Unsorted_Check()
{
int[] data = { 5, 2, 6, 3, 1, 4 };
int[] expected_sorted = { 1, 2, 3, 4, 5, 6 };
int[] expected_delete3 = { 1, 2, 4, 5, 6 };
int[] expected_delete2 = { 1, 4, 5, 6 };
int[] expected_delete6 = { 1, 4, 5 };
int[] expected_delete1 = { 4, 5 };
IBinarySearchTree<int> tree = new BinarySearchTree<int>();
foreach (int value in data)
tree.Insert(value);
int[] actualArray = tree.ToArray();
CollectionAssert.AreEqual(expected_sorted, actualArray);
Assert.IsTrue(tree.Delete(3));
CollectionAssert.AreEqual(expected_delete3, tree.ToArray());
Assert.IsTrue(tree.Delete(2));
CollectionAssert.AreEqual(expected_delete2, tree.ToArray());
Assert.IsTrue(tree.Delete(6));
CollectionAssert.AreEqual(expected_delete6, tree.ToArray());
Assert.IsTrue(tree.Delete(1));
CollectionAssert.AreEqual(expected_delete1, tree.ToArray());
}
public void Insert_SortedArray()
{
int[] data = {1, 2, 3, 4, 5, 6};
int[] expected = {1, 2, 3, 4, 5, 6};
IBinarySearchTree<int> tree = new BinarySearchTree<int>();
foreach (int value in data)
{
tree.Insert(value);
}
int[] actual = tree.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Insert_SmallUnsortedArray()
{
int[] data = new[] {5, 2, 6, 3, 1, 4};
int[] expected = {1, 2, 3, 4, 5, 6};
IBinarySearchTree<int> tree = new BinarySearchTree<int>();
foreach (int value in data)
tree.Insert(value);
int[] actualArray = tree.ToArray();
CollectionAssert.AreEqual(expected, actualArray);
}
public void Insert_OneValue_ToArray()
{
IBinarySearchTree<int> tree = new BinarySearchTree<int>();
tree.Insert(1);
int[] sortedArray = tree.ToArray();
Assert.IsTrue(tree.Find(1));
Assert.AreEqual(1, sortedArray.Length);
Assert.AreEqual(1, sortedArray[0]);
}
static void Main(string[] args)
{
const int seed = 0;
int[] sizes =
{
1000,
10000,
100000,
1000000
};
foreach (var count in sizes)
{
Random randNum = new Random(seed);
int[] random = Enumerable
.Repeat(0, count)
.Select(i => randNum.Next(0, int.MaxValue))
.ToArray();
int[] randomCopy = new int[random.Length];
random.CopyTo(randomCopy, 0);
int[] randomHeapCopy = new int[random.Length];
random.CopyTo(randomHeapCopy, 0);
int[] sorted = random.OrderBy(s => s).ToArray();
TimeSpan orderByTime = MeasureSort(s => s.OrderBy(t => t).ToArray(), random, sorted);
TimeSpan sortTime = MeasureSort(s =>
{
Array.Sort(s);
return s;
}, randomCopy, sorted);
TimeSpan heapTime = MeasureSort(Heap.HeapSort, random, sorted.Reverse().ToArray());
TimeSpan inplaceHeapTime = MeasureSort(Heap.InplaceHeapSort, randomHeapCopy, sorted.Reverse().ToArray());
TimeSpan bstTime = MeasureSort(s =>
{
BinarySearchTree<int> tree = new BinarySearchTree<int>();
foreach (int val in s)
{
tree.Insert(val);
}
return tree.ToArray();
}, random, sorted);
TimeSpan avlTime = MeasureSort(s =>
{
AvlTree<int> tree = new AvlTree<int>();
foreach (int val in s)
tree.Insert(val);
return tree.ToArray();
}, random, sorted);
Console.WriteLine("----- {0} -----", count);
Console.WriteLine("Heap: {0}", heapTime.TotalSeconds);
Console.WriteLine("Inplace Heap: {0}", inplaceHeapTime.TotalSeconds);
Console.WriteLine("Binary search tree: {0}", bstTime.TotalSeconds);
Console.WriteLine("AVL tree: {0}", avlTime.TotalSeconds);
Console.WriteLine("Sort: {0}", sortTime.TotalSeconds);
Console.WriteLine("OrderBy: {0}", orderByTime.TotalSeconds);
}
Console.ReadLine();
}
