public void Contains_EmptyTree_ReturnsFalse()
{
var tree = new AvlTree <int>();
tree.Contains(5).Should().BeFalse();
tree.Contains(-12).Should().BeFalse();
}
public void AvlTreeOperationsTest()
{
String value;
AvlTree <Int32, String> tree = new AvlTree <Int32, String>();
foreach (KeyValuePair <Int32, String> keyValuePair in this.values)
{
tree.Insert(keyValuePair.Key, keyValuePair.Value);
}
tree.Count.ShouldBe(this.values.Length);
foreach (KeyValuePair <Int32, String> keyValuePair in this.values)
{
tree.Contains(keyValuePair.Key).ShouldBeTrue();
tree.Search(keyValuePair.Key).ShouldBe(keyValuePair.Value);
tree.TrySearch(keyValuePair.Key, out value).ShouldBeTrue();
value.ShouldBe(keyValuePair.Value);
}
for (Int32 number = -1000; number < 1000; number++)
{
tree.Remove(number).ShouldBe(this.values.Select(keyValuePair => keyValuePair.Key).Contains(number));
}
tree.Count.ShouldBe(0);
foreach (KeyValuePair <Int32, String> keyValuePair in this.values)
{
tree.Insert(keyValuePair.Key, keyValuePair.Value);
}
tree.Clear();
tree.Count.ShouldBe(0);
foreach (KeyValuePair <Int32, String> keyValuePair in this.values)
{
tree.Contains(keyValuePair.Key).ShouldBeFalse();
tree.TrySearch(keyValuePair.Key, out value).ShouldBeFalse();
}
// exceptions
Should.Throw <ArgumentException>(() => tree.Search(0));
Should.Throw <ArgumentException>(() =>
{
tree.Insert(0, String.Empty);
tree.Insert(0, String.Empty);
});
AvlTree <Object, String> objectTree = new AvlTree <Object, String>();
Should.Throw <ArgumentNullException>(() => objectTree.Insert(null, null));
Should.Throw <ArgumentNullException>(() => objectTree.Contains(null));
Should.Throw <ArgumentNullException>(() => objectTree.TrySearch(null, out value));
Should.Throw <ArgumentNullException>(() => objectTree.Remove(null));
}
public void Contains_CorrectReturn()
{
var tree = new AvlTree <int>();
tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
tree.Contains(3).Should().BeTrue();
tree.Contains(7).Should().BeTrue();
tree.Contains(24).Should().BeFalse();
tree.Contains(-1).Should().BeFalse();
}
public void AddSameItems()
{
var item = 42;
for (var i = 0; i < 42; i++)
{
_avlTree.Insert(item);
}
_avlTree.Contains(item).Should().BeTrue();
_avlTree.Count.Should().Be(42);
}
public void CompareSearchTime()
{
var itemsCount = 10000;
var list = new List <int>();
for (int i = 0; i < itemsCount; i++)
{
list.Add(i);
}
var startTime = DateTime.Now;
list.Contains(5000);
var listContainsTime = DateTime.Now - startTime;
var avlTree = new AvlTree <int>();
for (int i = 0; i < itemsCount; i++)
{
avlTree.Add(i);
}
startTime = DateTime.Now;
avlTree.Contains(5000);
var avlContainsTime = DateTime.Now - startTime;
}
public void CompareSearchTime()
{
var itemsCount = 10000;
var list = new List<int>();
for (int i = 0; i < itemsCount; i++)
{
list.Add(i);
}
var startTime = DateTime.Now;
list.Contains(5000);
var listContainsTime = DateTime.Now - startTime;
var avlTree = new AvlTree<int>();
for (int i = 0; i < itemsCount; i++)
{
avlTree.Add(i);
}
startTime = DateTime.Now;
avlTree.Contains(5000);
var avlContainsTime = DateTime.Now - startTime;
}
private bool TestFind()
{
Console.WriteLine("Starting find test...");
foreach (var i in HelpList)
{
var result = AvlTree.Find(i);
if (result == 0)
{
Console.WriteLine($"could not find value {i}");
return(false);
}
if (result != i)
{
Console.WriteLine($"tree should find {i} but found {result}");
return(false);
}
if (!AvlTree.Contains(i))
{
Console.WriteLine($"Contains test failed... result = {result} i = {i}");
return(false);
}
}
Console.WriteLine("Find test successful");
return(true);
}
public void AvlTreeOperationsTest()
{
// test case 1: integer sequence
AvlTree <Int32, String> avl = new AvlTree <Int32, String>();
for (Int32 i = 0; i < 1000; i++)
{
avl.Insert(i, i.ToString());
}
for (Int32 i = 0; i < 1000; i++)
{
Assert.AreEqual(i.ToString(), avl.Search(i));
}
for (Int32 i = 0; i < 1000; i++)
{
Assert.IsTrue(avl.Remove(i));
}
Assert.AreEqual(0, avl.Count);
// test case 2: random numbers
avl = new AvlTree <Int32, String>();
List <Int32> keyList = new List <Int32>();
Random random = new Random();
for (Int32 i = 0; i < 10000; i++)
{
Int32 key = random.Next(1, 100000);
if (!avl.Contains(key))
{
avl.Insert(key, key.ToString());
keyList.Add(key);
}
}
Assert.AreEqual(keyList.Count, avl.Count);
for (Int32 i = 0; i < keyList.Count; i++)
{
Assert.AreEqual(keyList[i].ToString(), avl.Search(keyList[i]));
}
for (Int32 i = 0; i < keyList.Count; i++)
{
Assert.IsTrue(avl.Remove(keyList[i]));
}
Assert.AreEqual(0, avl.Count);
}
public void TestRemove()
{
var tree = new AvlTree <TestNode> ();
var t1 = new TestNode(1);
var t2 = new TestNode(2);
var t3 = new TestNode(3);
tree.Add(t2);
tree.Add(t1);
tree.Add(t3);
Assert.AreEqual(3, tree.Count);
Assert.IsTrue(tree.Remove(t2));
Assert.AreEqual(2, tree.Count);
Assert.IsTrue(tree.Contains(t1));
Assert.IsFalse(tree.Contains(t2));
Assert.IsTrue(tree.Contains(t3));
}
public void TestInOrderRemoval()
{
var tree = new AvlTree <TestNode> ();
TestNode[] nodes = new TestNode[10];
for (int i = 0; i < 10; i++)
{
tree.Add(nodes [i] = new TestNode(i));
}
Assert.AreEqual(10, tree.Count);
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(tree.Contains(nodes[i]), "case : " + i);
tree.Remove(nodes[i]);
Assert.IsFalse(tree.Contains(nodes[i]), "case : " + i);
}
Assert.AreEqual(0, tree.Count);
}
private bool TestDelete(int count)
{
Console.WriteLine("Starting delete test...");
var random = new Random(50);
HelpList.Sort((i1, i2) => i1 - i2);
for (int i = 0; i < count; i++)
{
var index = random.Next(0, HelpList.Count - 1);
var value = HelpList[index];
HelpList.Remove(value);
if (!AvlTree.Contains(value))
{
Console.WriteLine($"Tree does not contain that value {value}");
return(false);
}
var deletedValue = AvlTree.Delete(value);
if (value != deletedValue)
{
Console.WriteLine($"Wrong data deleted... should: {value}, was: {deletedValue}");
return(false);
}
if (AvlTree.Contains(value))
{
Console.WriteLine($"Tree still contains removed value {value}");
return(false);
}
if (i % 100 == 0)
{
if (!InOrderTest(false))
{
Console.WriteLine("In order test failed during deletion");
return(false);
}
}
}
if (!CountTest(true))
{
Console.WriteLine("Count test failed right after deletion");
return(false);
}
if (!InOrderTest(true))
{
Console.WriteLine("In order test failed right after deletion");
return(false);
}
Console.WriteLine("delete test successful");
return(true);
}
static void Main()
{
var tree = new AvlTree <int>();
Console.WriteLine("Count: " + tree.Count());
Console.WriteLine("Height: " + tree.Height());
for (int i = 0; i < 10000; ++i)
{
tree.Add(i);
}
Console.WriteLine("Count: " + tree.Count());
Console.WriteLine("Height: " + tree.Height());
for (int i = 0; i < 10000; ++i)
{
if (!tree.Contains(i))
{
throw new Exception("Doesn't work");
}
}
for (int i = 0; i < 10000; ++i)
{
tree.Remove(i);
}
Console.WriteLine("Count: " + tree.Count());
Console.WriteLine("Height: " + tree.Height());
for (int i = 0; i < 10000; ++i)
{
if (tree.Contains(i))
{
throw new Exception("Doesn't work");
}
}
Console.WriteLine("Works");
}
public void Remove_MultipleKeys_TreeStillValid()
{
var tree = new AvlTree <int>();
tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
tree.Remove(7);
tree.Count.Should().Be(9);
tree.Contains(7).Should().BeFalse();
tree.GetKeysInOrder().SequenceEqual(new[] { 1, 2, 3, 4, 5, 6, 8, 9, 10 }).Should().BeTrue();
tree.GetKeysPreOrder().SequenceEqual(new[] { 4, 2, 1, 3, 8, 6, 5, 9, 10 }).Should().BeTrue();
tree.Remove(2);
tree.Count.Should().Be(8);
tree.Contains(2).Should().BeFalse();
tree.Remove(1);
tree.Count.Should().Be(7);
tree.Contains(1).Should().BeFalse();
tree.GetKeysInOrder().SequenceEqual(new[] { 3, 4, 5, 6, 8, 9, 10 }).Should().BeTrue();
tree.GetKeysPreOrder().SequenceEqual(new[] { 8, 4, 3, 6, 5, 9, 10 }).Should().BeTrue();
tree.Remove(9);
tree.Count.Should().Be(6);
tree.Contains(9).Should().BeFalse();
tree.GetKeysInOrder().SequenceEqual(new[] { 3, 4, 5, 6, 8, 10 }).Should().BeTrue();
tree.GetKeysPreOrder().SequenceEqual(new[] { 6, 4, 3, 5, 8, 10 }).Should().BeTrue();
tree.Remove(3);
tree.Remove(4);
tree.Remove(5);
tree.Remove(6);
tree.Remove(8);
tree.Remove(10);
tree.Count.Should().Be(0);
tree.GetKeysInOrder().SequenceEqual(Array.Empty <int>()).Should().BeTrue();
}
public void Contains_NonAddedElement_ShouldReturnFalse()
{
var numbers = TestUtils.ToIntArrayUnique("1 7 3 -4 10 0");
var tree = new AvlTree <int>();
foreach (int number in numbers)
{
tree.Add(number);
}
var contains2 = tree.Contains(2);
Assert.IsFalse(contains2);
}
public void Contains_AddedElement_ShouldReturnTrue()
{
var numbers = TestUtils.ToIntArrayUnique("-2 3 10 0 1 -16");
var tree = new AvlTree <int>();
foreach (int number in numbers)
{
tree.Add(number);
}
var contains3 = tree.Contains(3);
Assert.IsTrue(contains3);
}
private void TestInsertion(int numberOfItems)
{
Console.WriteLine("Starting insertion...");
var random = new Random();
for (var i = 0; i < numberOfItems; i++)
{
var number = random.Next();
if (number == 0 || AvlTree.Contains(number))
{
continue;
}
AvlTree.Insert(number);
HelpList.Add(number);
}
Console.WriteLine("Insertion finished");
}
public int TestAvlTree()
{
var count = 0;
for (int i = 0; i < _data.Length; i++)
{
var number = _data[i];
if (_tree.Contains(number))
{
++count;
}
}
if (count != 0)
{
throw new Exception("Search error in AvlTree");
}
return(count);
}
private bool RandomRemoveInsertTest(int rounds)
{
Console.WriteLine("Starting random test...");
var randomSeed = new Random();
var randomCount = new Random(randomSeed.Next());
var randomInsOrDel = new Random(randomSeed.Next());
var randomInsertNumber = new Random(randomSeed.Next());
var randomDeleteNumber = new Random(randomSeed.Next());
//zistit kolko krat ideme robit mazanie/vkladanie
var help = 0;
while (help < rounds)
{
var count = randomCount.Next(100, 500);
var insOrDel = randomInsOrDel.NextDouble(); //0 insert, 1 delete
for (var i = 0; i < count; i++)
{
if (AvlTree.IsEmpty)
{
insOrDel = 0.2; //ak je prazdny nech radsej insertuje
}
if (insOrDel < 0.5)
{
var number = randomInsertNumber.Next();
if (number == 0 || AvlTree.Contains(number))
{
continue;
}
AvlTree.Insert(number);
HelpList.Add(number);
}
else
{
var index = randomDeleteNumber.Next(0, HelpList.Count - 1);
var value = HelpList[index];
HelpList.Remove(value);
if (!AvlTree.Contains(value))
{
Console.WriteLine($"Tree does not contain that value {value}");
return(false);
}
var deletedValue = AvlTree.Delete(value);
if (value != deletedValue)
{
Console.WriteLine($"Wrong data deleted... should: {value}, was: {deletedValue}");
return(false);
}
if (AvlTree.Contains(value))
{
Console.WriteLine($"Tree still contains removed value {value}");
return(false);
}
}
}
if (!CountTest(false))
{
Console.WriteLine("Count test failed during random test");
return(false);
}
if (!InOrderTest(false))
{
Console.WriteLine("In order test failed during random test");
return(false);
}
help++;
}
if (!CountTest(true))
{
Console.WriteLine("Count test failed right after random test");
return(false);
}
if (!InOrderTest(true))
{
Console.WriteLine("In order test failed right after random test");
return(false);
}
Console.WriteLine("Random test successful");
return(true);
}
public void AvlTreeBalanceTest()
{
// test case 1: ++, +
AvlTree <Int32, String> avl = new AvlTree <Int32, String>();
avl.Insert(1, "1");
avl.Insert(2, "2");
avl.Insert(3, "3");
Assert.IsTrue(avl.Select(element => element.Key).SequenceEqual(Enumerable.Range(1, 3)));
Assert.AreEqual(1, avl.Height);
// test case 2: --, -
avl = new AvlTree <Int32, String>();
avl.Insert(3, "1");
avl.Insert(2, "2");
avl.Insert(1, "3");
Assert.IsTrue(avl.Select(element => element.Key).SequenceEqual(Enumerable.Range(1, 3)));
Assert.AreEqual(1, avl.Height);
// test case 3: ++, -
avl = new AvlTree <Int32, String>();
avl.Insert(4, "1");
avl.Insert(2, "2");
avl.Insert(9, "3");
avl.Insert(6, "4");
avl.Insert(3, "5");
avl.Insert(10, "6");
avl.Insert(8, "7");
avl.Insert(11, "8");
avl.Insert(1, "9");
avl.Insert(5, "10");
avl.Insert(7, "11");
Assert.IsTrue(avl.Select(element => element.Key).SequenceEqual(Enumerable.Range(1, 11)));
Assert.AreEqual(3, avl.Height);
// test case 3: --, +
avl = new AvlTree <Int32, String>();
avl.Insert(8, "1");
avl.Insert(10, "2");
avl.Insert(3, "3");
avl.Insert(5, "4");
avl.Insert(11, "5");
avl.Insert(9, "6");
avl.Insert(1, "7");
avl.Insert(4, "8");
avl.Insert(2, "9");
avl.Insert(6, "10");
avl.Insert(7, "11");
Assert.IsTrue(avl.Select(element => element.Key).SequenceEqual(Enumerable.Range(1, 11)));
Assert.AreEqual(3, avl.Height);
// test case 4: ++, =
avl = new AvlTree <Int32, String>();
avl.Insert(4, "1");
avl.Insert(2, "2");
avl.Insert(5, "3");
avl.Insert(1, "4");
avl.Insert(3, "5");
avl.Remove(5);
Assert.IsTrue(avl.Select(element => element.Key).SequenceEqual(Enumerable.Range(1, 4)));
Assert.AreEqual(2, avl.Height);
// test case 5: --, =
avl = new AvlTree <Int32, String>();
avl.Insert(2, "1");
avl.Insert(1, "2");
avl.Insert(4, "3");
avl.Insert(5, "4");
avl.Insert(3, "5");
avl.Remove(1);
Assert.IsTrue(avl.Select(element => element.Key).SequenceEqual(Enumerable.Range(2, 4)));
Assert.AreEqual(2, avl.Height);
// test case 7: random tests
avl = new AvlTree <Int32, String>();
Random random = new Random();
for (Int32 i = 0; i < 10000; i++)
{
Int32 key = random.Next(1, 100000);
if (!avl.Contains(key))
{
avl.Insert(key, i.ToString());
}
}
Int32 prevKey = 0;
Int32 count = 0;
foreach (KeyValuePair <Int32, String> element in avl)
{
Assert.IsTrue(element.Key > prevKey);
prevKey = element.Key;
count++;
}
for (Int32 i = 0; i < 50000; i++)
{
Int32 key = random.Next(1, 100000);
if (avl.Contains(key))
{
avl.Remove(key);
}
}
prevKey = 0;
foreach (KeyValuePair <Int32, String> element in avl)
{
Assert.IsTrue(element.Key > prevKey);
prevKey = element.Key;
}
}
public void AddFirstElement()
{
_tree.Insert(1);
Assert.IsTrue(_tree.Contains(1));
Assert.AreEqual(1, _tree.Count);
}
public void AvlTreeEnumeratorTest()
{
// enumerator
AvlTree <Int32, String> tree = new AvlTree <Int32, String>();
foreach (KeyValuePair <Int32, String> keyValuePair in this.values)
{
if (!tree.Contains(keyValuePair.Key))
{
tree.Insert(keyValuePair.Key, keyValuePair.Value);
}
}
Int32 prevKey = this.values.Min(keyValuePair => keyValuePair.Key) - 1;
Int32 count = 0;
foreach (KeyValuePair <Int32, String> element in tree)
{
element.Key.ShouldBeGreaterThan(prevKey);
prevKey = element.Key;
count++;
}
count.ShouldBe(tree.Count);
// search tree enumerator
tree = new AvlTree <Int32, String>();
foreach (KeyValuePair <Int32, String> keyValuePair in this.values)
{
if (!tree.Contains(keyValuePair.Key))
{
tree.Insert(keyValuePair.Key, keyValuePair.Value);
}
}
ISearchTreeEnumerator <Int32, String> enumerator = tree.GetTreeEnumerator();
List <Int32> forwardList = new List <Int32>();
List <Int32> backwardList = new List <Int32>();
if (enumerator.MoveMin())
{
do
{
forwardList.Add(enumerator.Current.Key);
}while (enumerator.MoveNext());
}
if (enumerator.MoveMax())
{
do
{
backwardList.Add(enumerator.Current.Key);
}while (enumerator.MovePrev());
}
backwardList.Reverse();
forwardList.ShouldBe(backwardList);
}
public void Contains_AddedElement_ShouldReturnTrue()
{
var numbers = TestUtils.ToIntArrayUnique("-2 3 10 0 1 -16");
var tree = new AvlTree<int>();
foreach (int number in numbers)
{
tree.Add(number);
}
var contains3 = tree.Contains(3);
Assert.IsTrue(contains3);
}
public void Test2()
{
var s = new SortedDictionary <int, float>();
const int cnt = 10000000;
var raw = Enumerable.Range(1, cnt).ToArray();
var datas = raw.ToArray();
var rand = new Random();
for (var i = datas.Length - 1; i > 0; i--)
{
var value = datas[i];
var randomIndex = rand.Next(0, i);
datas[i] = datas[randomIndex];
datas[randomIndex] = value;
}
var tree = new AvlTree <int>();
foreach (var i in datas)
{
tree.Add(i);
}
Assert.True(tree.Min == 1);
Assert.True(tree.Max == cnt);
Assert.True(tree.Count == raw.Length);
var ind = 0;
foreach (var i in tree)
{
Assert.True(tree.Contains(i));
Assert.True(raw[ind] == i);
ind++;
}
Assert.False(tree.Contains(0));
Assert.False(tree.Contains(int.MinValue));
foreach (var i in tree)
{
var node = tree.FindNode(i);
Assert.True(node.HasValue);
var prev = tree.PreviousNode(node);
var next = tree.NextNode(node);
if (i == 1)
{
Assert.False(prev.HasValue);
}
else
{
Assert.True(prev.HasValue);
}
if (i == cnt)
{
Assert.False(next.HasValue);
}
else
{
Assert.True(next.HasValue);
}
var nearNext = tree.NearestNext(i, int.MaxValue);
var nearPrev = tree.NearestPrevious(i, int.MinValue);
if (i == cnt)
{
Assert.True(nearNext == int.MaxValue);
}
else
{
Assert.True(nearNext == i + 1);
}
if (i == 1)
{
Assert.True(nearPrev == int.MinValue);
}
else
{
Assert.True(nearPrev == i - 1);
}
}
Assert.True(tree.MaxHeight == tree.RecordHeight);
Console.WriteLine(tree.MaxHeight);
Console.WriteLine(Log2(cnt));
tree.CheckHeight();
}
public void TestRemove()
{
var tree = new AvlTree<TestNode> ();
var t1 = new TestNode (1);
var t2 = new TestNode (2);
var t3 = new TestNode (3);
tree.Add (t2);
tree.Add (t1);
tree.Add (t3);
Assert.AreEqual (3, tree.Count);
Assert.IsTrue (tree.Remove (t2));
Assert.AreEqual (2, tree.Count);
Assert.IsTrue (tree.Contains (t1));
Assert.IsFalse (tree.Contains (t2));
Assert.IsTrue (tree.Contains (t3));
}
public void TestReverseOrderRemoval()
{
var tree = new AvlTree<TestNode> ();
TestNode[] nodes = new TestNode[10];
for (int i = 0; i < 10; i++) {
tree.Add (nodes [i] = new TestNode (i));
}
Assert.AreEqual (10, tree.Count);
for (int i = 0; i < 10; i++) {
Assert.IsTrue (tree.Contains (nodes[9 - i]), "case : " + (9 - i));
tree.Remove (nodes[9 - i]);
Assert.IsFalse (tree.Contains (nodes[9 - i]), "case : " + (9 - i));
}
Assert.AreEqual (0, tree.Count);
}
public static void TestAvlTree()
{
AvlTree <int, int> avl = new AvlTree <int, int>();
avl.Add(10, 10);
avl.Add(9, 9);
avl.Add(8, 8);
avl.Add(7, 7);
avl.Add(6, 6);
avl.Add(5, 5);
avl.Add(4, 4);
avl.Add(3, 3);
avl.Add(2, 2);
avl.Add(1, 1);
//avl.AddByRecursion(10, 10);
//avl.AddByRecursion(9, 9);
//avl.AddByRecursion(8, 8);
//avl.AddByRecursion(7, 7);
//avl.AddByRecursion(6, 6);
//avl.AddByRecursion(5, 5);
//avl.AddByRecursion(4, 4);
//avl.AddByRecursion(3, 3);
//avl.AddByRecursion(2, 2);
//avl.AddByRecursion(1, 1);
Console.WriteLine("avl size:" + avl.Size);
Console.WriteLine("avl IsEmpty:" + avl.IsEmpty);
Console.WriteLine("avl IsBalanceBinaryTree:" + avl.IsBalanceBinaryTree());
Console.WriteLine("avl IsBinarySearchTree:" + avl.IsBinarySearchTree());
Console.WriteLine("avl Contains 4:" + avl.Contains(4));
Console.WriteLine("avl ContainsByRecursion 4:" + avl.ContainsByRecursion(4));
avl.PreOrderTraversal();
Console.WriteLine(avl.PreOrder.ToList().Translate());
avl.PreOrderTraversalByRecursion();
Console.WriteLine(avl.PreOrder.ToList().Translate());
avl.SequentialTraversal();
Console.WriteLine(avl.SequentialOrder.ToList().Translate());
avl.SequentialTraversalByRecursion();
Console.WriteLine(avl.SequentialOrder.ToList().Translate());
avl.PostOrderTraversal();
Console.WriteLine(avl.PostOrder.ToList().Translate());
avl.PostOrderTraversalByRecursion();
Console.WriteLine(avl.PostOrder.ToList().Translate());
avl.LevelOrderTraversal();
Console.WriteLine(avl.LevelOrder.ToList().Translate());
avl.LevelOrderTraversalByRecursion();
Console.WriteLine(avl.LevelOrder.ToList().Translate());
//avl.Remove(4);
//avl.Remove(6);
//avl.Remove(7);
//avl.Remove(9);
//avl.RemoveByRecursion(4);
//avl.RemoveByRecursion(6);
//avl.RemoveByRecursion(7);
//avl.RemoveByRecursion(9);
avl.RemoveMax();
avl.RemoveMin();
avl.RemoveMaxByRecursion();
avl.RemoveMinByRecursion();
Console.WriteLine("avl size:" + avl.Size);
Console.WriteLine("avl IsEmpty:" + avl.IsEmpty);
Console.WriteLine("avl IsBalanceBinaryTree:" + avl.IsBalanceBinaryTree());
Console.WriteLine("avl IsBinarySearchTree:" + avl.IsBinarySearchTree());
Console.WriteLine("avl Contains 4:" + avl.Contains(4));
Console.WriteLine("avl ContainsByRecursion 4:" + avl.ContainsByRecursion(4));
}
public void Contains_NonAddedElement_ShouldReturnFalse()
{
var numbers = TestUtils.ToIntArrayUnique("1 7 3 -4 10 0");
var tree = new AvlTree<int>();
foreach (int number in numbers)
{
tree.Add(number);
}
var contains2 = tree.Contains(2);
Assert.IsFalse(contains2);
}
public void BinarySearchTreeEnumeratorTest()
{
// test case 1
AvlTree <Int32, String> avl = new AvlTree <Int32, String>();
Random random = new Random();
for (Int32 i = 0; i < 1000; i++)
{
Int32 key = random.Next(1, 1000);
if (!avl.Contains(key))
{
avl.Insert(key, i.ToString());
}
}
Int32 prevKey = 0;
Int32 count = 0;
foreach (KeyValuePair <Int32, String> element in avl)
{
Assert.IsTrue(element.Key > prevKey);
prevKey = element.Key;
count++;
}
Assert.AreEqual(avl.Count, count);
// test case 2
avl = new AvlTree <Int32, String>();
random = new Random();
for (Int32 i = 0; i < 1000; i++)
{
Int32 key = random.Next(1, 1000);
if (!avl.Contains(key))
{
avl.Insert(key, i.ToString());
}
}
ISearchTreeEnumerator <Int32, String> enumerator = avl.GetTreeEnumerator();
List <Int32> forwardList = new List <Int32>();
List <Int32> backwardList = new List <Int32>();
if (enumerator.MoveMin())
{
do
{
forwardList.Add(enumerator.Current.Key);
} while (enumerator.MoveNext());
}
if (enumerator.MoveMax())
{
do
{
backwardList.Add(enumerator.Current.Key);
} while (enumerator.MovePrev());
}
backwardList.Reverse();
Assert.IsTrue(forwardList.SequenceEqual(backwardList));
}