public static void DoTest()
{
AVLTree<int> avlTree = new AVLTree<int>();
//
// CASE #1
// Insert: 4, 5, 7
// SIMPLE *left* rotation for node 4.
//
/***************************************
** UNBALANCED ===> BALANCED
** 4 5
** \ / \
** 5 ===> 4 7
** \
** 7
**
***************************************
*/
avlTree.Insert(4); // insert
avlTree.Insert(5); // insert
avlTree.Insert(7); // insert
// ASSERT CAST 1;
AssertCase_1(avlTree);
//
// CASE #2
// Insert to the previous tree: 2 and then 1.
// SIMPLE *right* rotation for node 4.
//
/*********************************************
** UNBALANCED ===> BALANCED
** 5 5
** / \ / \
** 4 7 ===> 2 7
** / / \
** 2 1 4
** /
** 1
**
*********************************************
*/
avlTree.Insert(2); // insert
avlTree.Insert(1); // insert
// ASSERT CASE 2
AssertCase_2(avlTree);
//
// CASE #3
// Insert to the previous tree: 3.
// DOUBLE *right* rotation for node 5.
//
// The double rotation is achieved by:
// 1> Simple *left* rotation for node 2, and then
// 2> Simple *right* rotation for node 5
//
/*************************************
** UNBALANCED ===> TRANSITION (1st R) ===> BALANCED (2nd Rt)
** 5 5 4
** / \ / \ / \
** 2 7 ===> 4 7 ===> 2 5
** / \ / / \ \
** 1 4 2 1 3 7
** / / \
** 3 1 3
**
*************************************
*/
avlTree.Insert(3); // insert
// ASSERT CASE 3
AssertCase_3(avlTree);
//
// CASE #4
// Insert to the previous tree: 6.
// DOUBLE *right* rotation for node 5.
//
// The double rotation is achieved by:
// 1> Simple *right* rotation for node 7, and then
// 2> Simple *left* rotation for node 5
//
/**************************************************************************
** UNBALANCED ===> TRANSITION (1st R) ===> BALANCED (2nd Rt)
** 4 4 ..4..
** / \ / \ / \
** 2 5 ===> 2 5 ===> 2 6
** / \ \ / \ \ / \ / \
** 1 3 7 1 3 6 1 3 5 7
** / \
** 6 7
**
**************************************************************************
*/
avlTree.Insert(6); // insert
// ASSERT CASE 4
AssertCase_4(avlTree);
//
// CASE #5
// REMOVE the tree's root: 4.
//
/**************************************************************************
** UNBALANCED ===> TRANSITION (1st R) ===> BALANCED (2nd Rt)
** null .6..
** / \ / \
** 2 6 ===> ===> 2 7
** / \ / \ / \ /
** 1 3 5 7 1 3 5
**
**************************************************************************
*/
avlTree.Remove(avlTree.Root.Value); // REMOVE 4
// ASSERT CASE 5
AssertCase_5(avlTree);
//
// CLEAR THE TREE AND START OVER
// Compare two binary trees with each other (height-wise) using bulk-inserts
avlTree = new AVLTree<int>();
var bsTree = new BinarySearchTree<int>();
List<int> treeDataList = new List<int>() { 15, 25, 5, 12, 1, 16, 20, 9, 9, 7, 7, -1, 11, 19, 30, 8, 10, 13, 28, 39 };
avlTree.Insert(treeDataList);
bsTree.Insert(treeDataList);
int avlTreeHeight = avlTree.Height;
int bsTreeHeight = bsTree.Height;
Debug.Assert(avlTreeHeight < bsTreeHeight, "Wrong heights. AVL Tree must be shorted than BS Tree.");
//
// Draw the tree to the console.
Console.WriteLine(String.Format("************\r\n** BST TREE:\r\n************\r\n"));
Console.WriteLine(bsTree.DrawTree());
Console.WriteLine("\r\n\r\n");
Console.WriteLine(String.Format("************\r\n** AVL TREE:\r\n************\r\n"));
Console.WriteLine(avlTree.DrawTree());
//
// OUTPUT OF AVL TREE DRAWER
/*****
** ************
** ** AVL TREE:
** ************
** ....15...
** / \
** ...9.. ..20.
** / \ / \
** ..5. 11 16 28
** / \ / \ / \ / \
** 1 7 9 12 19 25 30
** /\ / \ / \ / \ /\ /\ / \
** -1 7 8 10 13 39
** /\ /\ /\ /\ /\ /\
*
*/
treeDataList = new List<int>() { 15, 25, 5, 12, 1, 9, 7, -1, 11, 30, 8, 10, 13, 28, 39 };
avlTree.Clear();
avlTree.Insert(treeDataList);
Console.WriteLine(String.Format("************\r\n** AVL TREE:\r\n************\r\n"));
Console.WriteLine(avlTree.DrawTree());
//
// OUTPUT OF AVL TREE DRAWER
/*****
**
** .......9......
** / \
** .5 ....12...
** / \ / \
** 1 7 11 .25.
** /\ / \ /\ / \
** -1 8 10 15 30
** /\ /\ /\ /\ / \
** 13 28 39
** /\ /\ /\
**
*/
Console.ReadLine();
}//end-do-test
public static void DoTest()
{
AVLTree <int> avlTree = new AVLTree <int>();
//
// CASE #1
// Insert: 4, 5, 7
// SIMPLE *left* rotation for node 4.
//
/***************************************
** UNBALANCED ===> BALANCED
** 4 5
** \ / \
** 5 ===> 4 7
** \
** 7
**
***************************************
*/
avlTree.Insert(4); // insert
avlTree.Insert(5); // insert
avlTree.Insert(7); // insert
// ASSERT CAST 1;
AssertCase_1(avlTree);
//
// CASE #2
// Insert to the previous tree: 2 and then 1.
// SIMPLE *right* rotation for node 4.
//
/*********************************************
** UNBALANCED ===> BALANCED
** 5 5
** / \ / \
** 4 7 ===> 2 7
** / / \
** 2 1 4
** /
** 1
**
*********************************************
*/
avlTree.Insert(2); // insert
avlTree.Insert(1); // insert
// ASSERT CASE 2
AssertCase_2(avlTree);
//
// CASE #3
// Insert to the previous tree: 3.
// DOUBLE *right* rotation for node 5.
//
// The double rotation is achieved by:
// 1> Simple *left* rotation for node 2, and then
// 2> Simple *right* rotation for node 5
//
/*************************************
** UNBALANCED ===> TRANSITION (1st R) ===> BALANCED (2nd Rt)
** 5 5 4
** / \ / \ / \
** 2 7 ===> 4 7 ===> 2 5
** / \ / / \ \
** 1 4 2 1 3 7
** / / \
** 3 1 3
**
*************************************
*/
avlTree.Insert(3); // insert
// ASSERT CASE 3
AssertCase_3(avlTree);
//
// CASE #4
// Insert to the previous tree: 6.
// DOUBLE *right* rotation for node 5.
//
// The double rotation is achieved by:
// 1> Simple *right* rotation for node 7, and then
// 2> Simple *left* rotation for node 5
//
/**************************************************************************
** UNBALANCED ===> TRANSITION (1st R) ===> BALANCED (2nd Rt)
** 4 4 ..4..
** / \ / \ / \
** 2 5 ===> 2 5 ===> 2 6
** / \ \ / \ \ / \ / \
** 1 3 7 1 3 6 1 3 5 7
** / \
** 6 7
**
**************************************************************************
*/
avlTree.Insert(6); // insert
// ASSERT CASE 4
AssertCase_4(avlTree);
//
// CASE #5
// REMOVE the tree's root: 4.
//
/**************************************************************************
** UNBALANCED ===> TRANSITION (1st R) ===> BALANCED (2nd Rt)
** null .6..
** / \ / \
** 2 6 ===> ===> 2 7
** / \ / \ / \ /
** 1 3 5 7 1 3 5
**
**************************************************************************
*/
avlTree.Remove(avlTree.Root.Value); // REMOVE 4
// ASSERT CASE 5
AssertCase_5(avlTree);
//
// CLEAR THE TREE AND START OVER
// Compare two binary trees with each other (height-wise) using bulk-inserts
avlTree = new AVLTree <int>();
var bsTree = new BinarySearchTree <int>();
List <int> treeDataList = new List <int>()
{
15, 25, 5, 12, 1, 16, 20, 9, 9, 7, 7, -1, 11, 19, 30, 8, 10, 13, 28, 39
};
avlTree.Insert(treeDataList);
bsTree.Insert(treeDataList);
int avlTreeHeight = avlTree.Height;
int bsTreeHeight = bsTree.Height;
Debug.Assert(avlTreeHeight < bsTreeHeight, "Wrong heights. AVL Tree must be shorted than BS Tree.");
//
// Draw the tree to the console.
Console.WriteLine("************\r\n** BST TREE:\r\n************\r\n");
Console.WriteLine(bsTree.DrawTree());
Console.WriteLine("\r\n\r\n");
Console.WriteLine("************\r\n** AVL TREE:\r\n************\r\n");
Console.WriteLine(avlTree.DrawTree());
//
// OUTPUT OF AVL TREE DRAWER
/**
** .....15....
** / \
** ...9... .20
** / \ / \
** .5 11 16 28
** / \ / \ \ / \
** 1 7 9 12 19 25 30
** / / \ \ \ \
** -1 7 8 10 13 39
*/
treeDataList = new List <int>()
{
15, 25, 5, 12, 1, 9, 7, -1, 11, 30, 8, 10, 13, 28, 39
};
avlTree.Clear();
avlTree.Insert(treeDataList);
Console.WriteLine("************\r\n** AVL TREE:\r\n************\r\n");
Console.WriteLine(avlTree.DrawTree());
//
// OUTPUT OF AVL TREE DRAWER
/**
** ....9...
** / \
** 5 .12.
** / \ / \
** 1 7 11 25
** / \ / / \
** -1 8 10 15 30
** / / \
** 13 28 39
*/
Console.ReadLine();
}//end-do-test
public void ClearTest(AVLTree <int> actualTree, AVLTree <int> expected)
{
actualTree.Clear();
CollectionAssert.AreEqual(expected, actualTree);
}
public virtual void Clear()
{
_wrapped.Clear();
}
public void AddingAfterClearingTree()
{
var tree = new AVLTree <int>();
int elementsCount = 100000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.Contains(el))
{
tree.Add(el);
}
el += i;
}
}
if (tree.Count != elementsCount)
{
Assert.Fail();
}
tree.Clear();
if (tree.Count != 0)
{
Assert.Fail();
}
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.Contains(el))
{
tree.Add(el);
}
el += i;
}
}
int last = -1;
int count = 0;
bool elementsAreSorted = true;
foreach (var item in tree)
{
if (last > item)
{
elementsAreSorted = false;
}
last = item;
count++;
}
Assert.IsTrue(tree.Count == elementsCount &&
elementsAreSorted &&
count == elementsCount);
}
public void ExecuteTestTree()
{
List <string> hashes = new List <string>();
List <string> values = new List <string>();
const int size = 1000;
Console.WriteLine("Small Tests...");
Assert.IsTrue(tree.Count == 0);
tree.Add(new KeyValuePair <string, string>("key", "value"));
Assert.IsTrue(tree.ContainsKey("key"));
Assert.IsFalse(tree.ContainsKey("value"));
Assert.IsTrue(tree["key"] == "value");
Assert.IsTrue(tree.Count == 1);
tree.Validate();
tree.Add(new KeyValuePair <string, string>("key", "value2"));
Assert.IsTrue(tree.ContainsKey("key"));
Assert.IsFalse(tree.ContainsKey("value"));
Assert.IsTrue(tree["key"] == "value2");
Assert.IsTrue(tree.Count == 1);
tree.Validate();
tree.Add(new KeyValuePair <string, string>("key", "avalue"));
Assert.IsTrue(tree.ContainsKey("key"));
Assert.IsFalse(tree.ContainsKey("value"));
Assert.IsTrue(tree["key"] == "avalue");
Assert.IsTrue(tree.Count == 1);
tree.Validate();
Assert.IsFalse(tree.Remove("value"));
Assert.IsTrue(tree.Remove("key"));
tree.Validate();
Assert.IsTrue(tree.Count == 0);
tree.Add(new KeyValuePair <string, string>("key", "value2"));
Assert.IsTrue(tree.Count == 1);
tree.Clear();
Assert.IsTrue(tree.Count == 0);
tree.Add(new KeyValuePair <string, string>("key", "value"));
Assert.IsTrue(tree.ContainsKey("key"));
Assert.IsFalse(tree.ContainsKey("value"));
Assert.IsTrue(tree["key"] == "value");
Assert.IsTrue(tree.Count == 1);
tree.Validate();
tree.Clear();
Assert.IsFalse(tree.Remove(""));
Assert.IsFalse(tree.Remove(new KeyValuePair <string, string>("", "")));
Console.WriteLine("Adding...");
for (int i = 0; i < size; i++)
{
Assert.IsTrue(tree.Count == i);
hashes.Add(Hash.GetHash());
values.Add(Hash.GetHash());
tree[hashes[i]] = values[i];
Assert.IsTrue(tree[hashes[i]] == values[i]);
Assert.IsTrue(tree.Keys.Contains(hashes[i]));
Assert.IsTrue(tree.Values.Contains(values[i]));
tree.Validate();
}
Console.WriteLine("Overriding...");
for (int i = 0; i < size; i++)
{
Assert.IsTrue(tree[hashes[i]] == values[i]);
values[i] = Hash.GetHash();
tree[hashes[i]] = values[i];
Assert.IsTrue(tree.Count == size);
}
Console.WriteLine("Checking...");
for (int i = 0; i < size; i++)
{
Assert.IsTrue(tree[hashes[i]] == values[i]);
Assert.IsTrue(tree.Keys.Contains(hashes[i]));
Assert.IsTrue(tree.Values.Contains(values[i]));
}
Console.WriteLine("Validating...");
tree.Validate();
Console.WriteLine("Deleting...");
for (int i = 0; i < size; i++)
{
Assert.IsTrue(tree.Count == size - i);
Assert.IsTrue(tree.ContainsKey(hashes[i]));
Assert.IsTrue(tree[hashes[i]] != default(string));
Assert.IsTrue(tree.Remove(hashes[i]));
Assert.IsFalse(tree.Keys.Contains(hashes[i]));
Assert.IsFalse(tree.Values.Contains(values[i]));
if (true)
{
for (int j = i + 1; j < size; j++)
{
Assert.IsFalse(tree[hashes[j]].Contains(hashes[j]));
}
for (int j = 0; j < i; j++)
{
Assert.IsFalse(tree.Remove(hashes[j]));
}
}
Assert.IsTrue(tree[hashes[i]] == default(string));
tree.Validate();
}
Serializer.WriteXmlData(tree, nameof(tree));
tree = Serializer.ReadXmlData <AVLTree <string, string> >(nameof(tree));
tree.Validate();
}
public void TestAvlTrees()
{
tree = new AVLTree <string, string>();
ExecuteTestTree();
tree.Clear();
}
/// <summary>
/// Clears the Subnodes of this node.
/// </summary>
public void ClearNodes()
{
_subNodes.Clear();
}