static void Main(string[] args)
{
AVLTree<int> tree = new AVLTree<int>();
tree.Add(50);
tree.Add(2);
tree.Add(7);
tree.Add(94);
tree.Add(24);
tree.Add(24);
tree.Add(71);
tree.Add(30);
tree.Add(49);
Console.WriteLine("Count: " + tree.count()); // Should be 9
Console.WriteLine("Min: " + tree.min()); // Should be 2
Console.WriteLine("Max: " + tree.max()); // Should be 94
Console.WriteLine("Depth: " + tree.depth()); // Should be 7
tree.print(); // Prints the values in order
tree.Remove(49); // test for value not in tree
tree.Remove(51); // test for value not in tree
tree.Remove(50);
tree.Remove(2);
tree.Remove(7);
tree.Remove(94);
tree.Remove(24);
tree.Remove(24);
tree.Remove(71);
tree.Remove(30);
tree.Remove(49);
Console.WriteLine("Count: " + tree.count()); // Should be 0
Console.WriteLine("Min: " + tree.min()); // Should be -1
Console.WriteLine("Max: " + tree.max()); // Should be -1
Console.WriteLine("Depth: " + tree.depth()); // Should be 0
tree.print(); // Prints the values in order
}
static void Main(string[] args)
{
AVLTree<int, int> tree1 = new AVLTree<int, int>();
AVLTree<int, int> tree2 = new AVLTree<int, int>();
tree1.Insert(1, 1);
tree1.Insert(465456544, 465456544);
tree1.Insert(43, 43);
tree1.Insert(-43, -43);
tree1.Insert(-66, -66);
tree2.Insert(1, 1);
tree2.Insert(465456544, 465456544);
tree2.Insert(43, 43);
tree2.Insert(-43, -43);
tree2.Insert(-66, -66);
Console.WriteLine(tree1);
Console.WriteLine("hash codes: " + tree1.GetHashCode() + " " + tree2.GetHashCode());
Console.WriteLine("tree1 == tree2 " + (tree1 == tree2));
foreach (var node in tree1)
{
Console.WriteLine(node);
}
}
public void BasicAVLTreeTest()
{
var tree = new AVLTree<int>();
Assert.AreEqual(0, tree.Height);
for (int i = 0; i < 10; i++)
{
tree.Add(i);
}
Assert.AreEqual(4, tree.Height);
Assert.AreEqual(10, tree.Size);
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(tree.Contains(i));
}
Assert.IsFalse(tree.Contains(11));
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(tree.Remove(i));
}
Assert.AreEqual(0, tree.Height);
Assert.AreEqual(0, tree.Size);
}
public static void RunAddingAndRemovalSpeedTest()
{
const int NUMBER_OF_ELEMENTS = 1000000;
AVLTree<int> tree = new AVLTree<int>();
Console.WriteLine("Adding {0} elements...", NUMBER_OF_ELEMENTS);
var watch1 = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < NUMBER_OF_ELEMENTS; i++)
{
tree.Insert(i);
}
watch1.Stop();
Console.WriteLine("Elapsed time for insertion: {0}ms", watch1.ElapsedMilliseconds);
Console.WriteLine("Count: {0}", tree.Count);
Console.WriteLine("Height: {0}", tree.Height);
Console.WriteLine("Removing almost all elements...");
var watch2 = System.Diagnostics.Stopwatch.StartNew();
for (int i = tree.Count - 1; i > 4; i--)
{
tree.Remove(i);
}
watch2.Stop();
Console.WriteLine("Elapsed time for removal: {0}ms", watch2.ElapsedMilliseconds);
Console.WriteLine("Elements left: ");
foreach (var item in tree)
{
Console.Write("({0}) ", item); // expected output - (0) (1) (2) (3) (4)
}
Console.WriteLine("\nCount: {0}", tree.Count); // expected output - 5
Console.WriteLine("Height: {0}", tree.Height); // expected output - 3
}
protected override void DoReceive()
{
// get relation info
var reldata = AccountRelationDataStore.Get(_authInfo.Id);
var beforeFollowing = new AVLTree<long>(reldata.Following);
var beforeFollowers = new AVLTree<long>(reldata.Followers);
var beforeBlockings = new AVLTree<long>(reldata.Blockings);
// get followings / followers
Observable.Merge(
_authInfo.GetFriendsIdsAll(_authInfo.Id)
.Do(id => beforeFollowing.Remove(id))
.Do(reldata.AddFollowing),
_authInfo.GetFollowerIdsAll(_authInfo.Id)
.Do(id => beforeFollowers.Remove(id))
.Do(reldata.AddFollower),
_authInfo.GetBlockingsIdsAll()
.Do(id => beforeBlockings.Remove(id))
.Do(reldata.AddBlocking))
.Subscribe(_ => { },
ex => BackstageModel.RegisterEvent(
new OperationFailedEvent("relation receive error: " +
_authInfo.UnreliableScreenName + " - " +
ex.Message)),
() =>
{
// cleanup remains
beforeFollowing.ForEach(reldata.RemoveFollowing);
beforeFollowers.ForEach(reldata.RemoveFollower);
beforeBlockings.ForEach(reldata.RemoveBlocking);
});
}
public static void RunSearchingSpeedTest()
{
const int NUMBER_OF_ELEMENTS_IN_TREE1 = 1000;
const int NUMBER_OF_ELEMENTS_IN_TREE2 = 10000;
const int NUMBER_OF_ELEMENTS_IN_TREE3 = 1000000;
const int TIMES_SEARCHED = 100000;
AVLTree<int> tree1 = new AVLTree<int>();
AVLTree<int> tree2 = new AVLTree<int>();
AVLTree<int> tree3 = new AVLTree<int>();
for (int i = 0; i < NUMBER_OF_ELEMENTS_IN_TREE3; i++)
{
if (i < NUMBER_OF_ELEMENTS_IN_TREE1)
{
tree1.Insert(i);
}
if (i < NUMBER_OF_ELEMENTS_IN_TREE2)
{
tree2.Insert(i);
}
tree3.Insert(i);
}
Console.WriteLine("Searching in tree1...");
var watch1 = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < TIMES_SEARCHED; i++)
{
tree1.Contains(GetRandomNumber(NUMBER_OF_ELEMENTS_IN_TREE1));
}
watch1.Stop();
Console.WriteLine("Elapsed time: {0}ms\n", watch1.ElapsedMilliseconds);
Console.WriteLine("Searching in tree2...");
var watch2 = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < TIMES_SEARCHED; i++)
{
tree1.Contains(GetRandomNumber(NUMBER_OF_ELEMENTS_IN_TREE2));
}
watch2.Stop();
Console.WriteLine("Elapsed time: {0}ms\n", watch2.ElapsedMilliseconds);
Console.WriteLine("Searching in tree3...");
var watch3 = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < TIMES_SEARCHED; i++)
{
tree1.Contains(GetRandomNumber(NUMBER_OF_ELEMENTS_IN_TREE3));
}
watch3.Stop();
Console.WriteLine("Elapsed time: {0}ms\n", watch3.ElapsedMilliseconds);
int magicNumberOutside = 1230;
int magicNumberInside = 900;
Console.WriteLine("Tree1 contains {0}: {1}\n", magicNumberOutside, tree1.Contains(magicNumberOutside)); // expected output - false
Console.WriteLine("Tree1 contains {0}: {1}\n", magicNumberInside, tree1.Contains(magicNumberInside)); // expected output - true
}
public void InsertionRightLeftTest()
{
var d = new AVLTree<int, int>();
d.Add(1, 0);
d.Add(10, 0);
d.Add(5, 0);
CheckTree(d, "<5<1><10>>");
}
private void CheckRemove(long id, AVLTree<long> prevList, List<long> newList)
{
// if fails removing
if (!prevList.Remove(id))
{
// that's new item
newList.Add(id);
}
}
public override Func<TwitterStatus, IReadOnlyCollection<long>> GetSetValueProvider()
{
var tempList = new AVLTree<long>();
lock (_watcher.Ids)
{
_watcher.Ids.ForEach(tempList.Add);
}
return _ => tempList;
}
public void InversionTest()
{
// add elements
var tree = new AVLTree<int>(Comparer<int>.Create((i, j) => j - i));
tree.Add(1);
tree.Add(2);
tree.Add(3);
Assert.AreEqual(tree.Select(i => i.ToString()).JoinString(","), "3,2,1");
}
public void AddDistinctTest()
{
// add elements
var tree = new AVLTree<int>();
tree.Add(1);
tree.Add(1);
tree.Add(1);
Assert.AreEqual(tree.Select(i => i.ToString()).JoinString(","), "1");
}
public void RemoveTest()
{
// add elements
var tree = new AVLTree<int>();
tree.Add(1);
tree.Add(2);
tree.Add(3);
tree.Remove(3);
tree.Remove(2);
Assert.AreEqual(tree.Select(i => i.ToString()).JoinString(","), "1");
}
public void InsertionDeepRightLeftTest()
{
var d = new AVLTree<int, int>();
d.Add(10, 0);
d.Add(5, 0);
d.Add(11, 0);
CheckTree(d, "<10<5><11>>");
d.Add(20, 0);
CheckTree(d, "<10<5><11<><20>>>");
d.Add(15, 0);
CheckTree(d, "<10<5><15<11><20>>>");
}
public static void Main()
{
AVLTree<int> tree = new AVLTree<int>();
AddElements(tree, 15);
PrintTree(tree, TraverseOrder.InOrder);
PrintTree(tree, TraverseOrder.PreOrder);
PrintTree(tree, TraverseOrder.PostOrder);
PrintTree(tree, TraverseOrder.RightLeftParentOrder);
DisplayHeight(tree);
}
/// <summary>
/// 設定情報からアカウント情報を読み込み、アカウント情報が変化した際に自動で保存するトリガを準備します。
/// </summary>
internal static void Initialize()
{
if (_isInitialized)
throw new InvalidOperationException("AccountsModel has already initialized.");
_isInitialized = true;
Setting.Infrastructure_Accounts.ForEach(Accounts.Add);
// writeback delegate
Accounts.CollectionChanged += (_, __) =>
{
Setting.Infrastructure_Accounts = Accounts;
_accountsIdCollection = null;
};
}
public void AssertValidTree_InvalidBalance_Left()
{
var root = new AVLNode<int>(100);
root.Left = new AVLNode<int>(50);
root.Right = new AVLNode<int>(150);
root.Left.Left = new AVLNode<int>(30);
root.Left.Left.Left = new AVLNode<int>(20);
AVLTree<int> bst = new AVLTree<int>();
bst.Root = root;
bst.AssertValidTree();
}
public void AddAndRemove()
{
var avl = new AVLTree<int, int> { { 10, 10 }, { 20, 20 }, { 30, 30 }, { 40, 40 }, { 50, 50 } };
Assert.IsTrue(avl.Remove(30));
Assert.IsFalse(avl.Remove(70));
Assert.AreEqual(avl.Count, 4);
var expected = new[] { 10, 20, 40, 50 };
var index = 0;
foreach (var item in avl)
{
Assert.AreEqual(item.Key, expected[index]);
index++;
}
}
private static void AVLTreeTest()
{
AVLTree<int, int> avl = new AVLTree<int, int>();
for (int i = 1; i < 11; i++)
{
avl.Add(i, i);
}
Console.WriteLine("Root:{0}", avl.Root.Key.ToString());
Console.WriteLine("Height:{0}", avl.Root.Height);
Console.WriteLine("Inorder:{0}", avl.Print());
Queue<AVLNode<int, int>> que = new Queue<AVLNode<int, int>>();
ViewAVLLayer(avl.Root, que);
}
public void AddRemoveAndBalance()
{
var avl = new AVLTree<int, int> { { 9, 9 }, { 77, 77 }, { 50, 50 }, { 48, 48 }, { 24, 24 }, { 60, 60 }, { 72, 72 }, { 95, 95 }, { 66, 66 }, { 27, 27 } };
Assert.IsFalse(avl.Remove(30));
Assert.IsTrue(avl.Remove(77));
Assert.IsTrue(avl.Remove(72));
Assert.IsTrue(avl.Remove(27));
var expected = new[] { 9, 24, 48, 50, 60, 66, 95 };
Assert.AreEqual(avl.Count, expected.Length);
var index = 0;
foreach (var item in avl)
{
Assert.AreEqual(item.Key, expected[index]);
index++;
}
}
public TimelineModel(Func<TwitterStatus, bool> evaluator,
Func<long?, int, bool, IObservable<TwitterStatus>> fetcher)
{
_fetcher = fetcher;
_statusIdCache = new AVLTree<long>();
_disposable = new CompositeDisposable();
// add handler
_disposable.Add(StatusStore.StatusPublisher
.Where(sn => sn.IsAdded && evaluator(sn.Status))
.Select(s => s.Status)
.Subscribe(AddStatus));
// remove handler
_disposable.Add(StatusStore.StatusPublisher
.Where(sn => !sn.IsAdded || !evaluator(sn.Status))
.Select(s => s.StatusId)
.Subscribe(RemoveStatus));
}
public static void Main()
{
var binaryTree = new AVLTree<int>();
Console.WriteLine("The AVL tree created.");
AddNumber(binaryTree, 5);
AddNumber(binaryTree, 20);
AddNumber(binaryTree, 14);
AddNumber(binaryTree, 11);
AddNumber(binaryTree, 8);
AddNumber(binaryTree, 3);
AddNumber(binaryTree, 1);
binaryTree.Remove(5);
Console.WriteLine("Deleted 5");
Traverse(binaryTree.Root, "");
Console.WriteLine("----------------------");
}
/// <summary>
/// Load button click
/// Reads csv file and creates country objects to be added to the tree
/// </summary>
private void button3_Click(object sender, EventArgs e)
{
const int MAX_LINES_FILE = 50000;
string[] AllLines = new string[MAX_LINES_FILE];
tree = new AVLTree<Country>();
OpenFileDialog openFile = new OpenFileDialog();
openFile.Filter = "csv files (*.csv)|*.csv";
if (openFile.ShowDialog() == DialogResult.OK)
{
try
{
AllLines = File.ReadAllLines(openFile.FileName);
foreach (string line in AllLines)
{
if (line.StartsWith("Country"))
{
headers = line.Split(',');
}
else
{
string[] columns = line.Split(',');
string[] partners = columns[5].Split(';', '[', ']');
LinkedList<String> tPartners = new LinkedList<string>();
for (int i = 1; i < partners.Length - 1; i++)
{
tPartners.AddLast(partners[i]);
}
//Creates a new country object and adds to tree
Country country = new Country(columns[0], columns[1], columns[2], columns[3], columns[4], tPartners);
tree.InsertItem(country);
}
}
populateListView(false);
treeDepth();
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public void PreOrderBalancingTest()
{
AVLTree<int> tree = new AVLTree<int>();
tree.Add(4);
tree.Add(5);
tree.Add(2);
tree.Add(7);
tree.Add(3);
tree.Add(6);
tree.Add(1);
tree.Add(8);
int[] expected = new[] { 4, 2, 1, 3, 6, 5, 7, 8 };
int index = 0;
tree.PreOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order"));
}
public void InOrderBalancingTest()
{
AVLTree<int> tree = new AVLTree<int>();
//No matter whatr the input is, output is sorted data
tree.Add(4);
tree.Add(5);
tree.Add(2);
tree.Add(7);
tree.Add(3);
tree.Add(6);
tree.Add(1);
tree.Add(8);
int[] expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
int index = 0;
tree.InOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order"));
}
// ReSharper restore TooWideLocalVariableScope
// ReSharper restore FunctionNeverReturns
private static bool ValidateStatus(TwitterStatus status)
{
if (_cacheInvalid)
{
var nbs = new AVLTree<long>();
AccountRelationDataStore.AccountRelations
.SelectMany(a => a.Blockings)
.ForEach(nbs.Add);
_blockings = nbs;
_cacheInvalid = false;
}
if (_predicateInvalid)
{
_muteEval = Setting.Muteds.Evaluator;
_predicateInvalid = false;
}
if (_blockings.Contains(status.User.Id)) return false;
if (_muteEval(status)) return false;
return status.RetweetedOriginal == null || ValidateStatus(status.RetweetedOriginal);
}
public TimelineModel(Func<TwitterStatus, bool> evaluator,
Func<long?, int, bool, IObservable<TwitterStatus>> fetcher)
{
_fetcher = fetcher;
_statusIdCache = new AVLTree<long>();
_disposable = new CompositeDisposable();
// register handler
_disposable.Add(StatusStore.StatusPublisher
.Subscribe(sn =>
{
if (sn.IsAdded && evaluator(sn.Status))
{
AddStatus(sn.Status);
}
else
{
RemoveStatus(sn.StatusId);
}
}));
}
public static void Main(string[] args)
{
Dictionary<DateTime, int> dic = new Dictionary<DateTime, int> ();
AVLTree<DateTime, int> tree = new AVLTree<DateTime, int> ();
for (int i = 0; i < 1000000; i++) {
dic.Add (DateTime.Now.AddMinutes (i), i);
tree.add (DateTime.Now.AddMinutes (i), i);
}
var min = Convert.ToDateTime ("2013/8/21 4:00:00");
var max = Convert.ToDateTime ("2013/8/21 5:00:00");
var watch = Stopwatch.StartNew ();
var result = dic.Keys.Where (i => i >= min && i <= max).Select (i => dic [i]).ToList ();
watch.Stop ();
Console.WriteLine("字典查找耗费时间:{0}ms", watch.ElapsedMilliseconds);
watch = Stopwatch.StartNew ();
var result2 = tree.searchRange (min, max);
watch.Stop ();
Console.WriteLine("平衡二叉树查找耗费时间:{0}ms", watch.ElapsedMilliseconds);
}
protected override void DoReceive()
{
// get relation account
var reldata = this._account.RelationData;
var beforeFollowings = new AVLTree<long>(reldata.Followings);
var beforeFollowers = new AVLTree<long>(reldata.Followers);
var beforeBlockings = new AVLTree<long>(reldata.Blockings);
var newFollowings = new List<long>();
var newFollowers = new List<long>();
var newBlockings = new List<long>();
// get followings / followers
Observable.Merge(
this._account.RetrieveAllCursor((a, c) => a.GetFriendsIdsAsync(this._account.Id, c))
.Do(id => this.CheckRemove(id, beforeFollowings, newFollowings)),
this._account.RetrieveAllCursor((a, c) => a.GetFollowersIdsAsync(this._account.Id, c))
.Do(id => this.CheckRemove(id, beforeFollowers, newFollowers)),
this._account.RetrieveAllCursor((a, c) => a.GetBlockingsIdsAsync(c))
.Do(id => this.CheckRemove(id, beforeBlockings, newBlockings)))
.Subscribe(_ => { },
ex =>
{
BackstageModel.RegisterEvent(
new OperationFailedEvent("relation receive error: " +
this._account.UnreliableScreenName + " - " +
ex.Message));
System.Diagnostics.Debug.WriteLine(ex);
},
() => Task.Run(async () =>
{
await reldata.RemoveFollowingsAsync(beforeFollowings);
await reldata.AddFollowingsAsync(newFollowings);
await reldata.RemoveFollowersAsync(beforeFollowers);
await reldata.AddFollowersAsync(newFollowers);
await reldata.RemoveBlockingsAsync(beforeBlockings);
await reldata.AddBlockingsAsync(newBlockings);
}));
}
private void ShowPrintQueue(int highlightedOne)
{
//Отобразить состояние очереди
richTextBox3.Text = "";
AVLTree<Client> reservedQueue = new AVLTree<Client>();
Client[] clientArr = new Client[highlightedOne];
m_printerQueue.CopyTo(clientArr);//скопруем очередь в массив клиентов
foreach (Client element in clientArr)
{
// делаем копию очереди reservedQueue, ее и распечатываем
reservedQueue.Add(element);
}
int count = reservedQueue.Count;
for (int i = 0; i < count; i++)
{
Client peekedClient = reservedQueue.MaxValue;//метод, возвращающий клиента с максимальным приоритетом
bool d = reservedQueue.Remove(peekedClient);
richTextBox3.Text += (i + 1).ToString() + ". " + peekedClient.GetClientName() + " ("
+ peekedClient.GetPriority() + ")" + " [" + peekedClient.GetLeftTime() + "]";
if (i == highlightedOne || peekedClient.GetTimeInQueue() < 3)
richTextBox3.Text += " <<<";
richTextBox3.Text += "\n";
}
}
//
// DEBUG.ASSERT <- CASE 5
private static void AssertCase_5(AVLTree<int> avlTree)
{
var avlRoot = avlTree.Root;
Debug.Assert(avlRoot.Height == 2, "Wrong root height!");
Debug.Assert(avlRoot.Value == 6, "Wrong root.");
Debug.Assert(avlRoot.LeftChild.Value == 2, "Wrong left child from root.");
Debug.Assert(avlRoot.RightChild.Value == 7, "Wrong right child from root.");
Debug.Assert(avlRoot.LeftChild.LeftChild.Value == 1, "Wrong value at {root->left->left}.");
Debug.Assert(avlRoot.LeftChild.RightChild.Value == 3, "Wrong value at {root->left->right}.");
Debug.Assert(avlRoot.RightChild.LeftChild.Value == 5, "Wrong value at {root->right->left}.");
Debug.Assert(avlRoot.RightChild.RightChild == null, "Wrong value at {root->right->right}.");
Debug.Assert(
avlRoot.LeftChild.LeftChild.Height == 0
&& avlRoot.LeftChild.RightChild.Height == 0
&& avlRoot.RightChild.LeftChild.Height == 0
,
"Wrong heights at the leaf nodes!.");
}
public void Setup()
{
var source = new Node
{
Name = "Start",
Edges = new List <Edge>()
};
var cityA = new Node
{
Name = "A",
Edges = new List <Edge>()
};
var cityB = new Node
{
Name = "B",
Edges = new List <Edge>()
};
var end = new Node
{
Name = "End",
Edges = new List <Edge>()
};
var sourceToA = new Edge
{
To = cityA,
Capacity = 5
};
var aToSource = new Edge
{
To = source,
Capacity = 5
};
sourceToA.BackEdge = aToSource;
aToSource.BackEdge = sourceToA;
var sourceToB = new Edge
{
To = cityB,
Capacity = 6
};
var bTosource = new Edge
{
To = source,
Capacity = 6
};
sourceToB.BackEdge = bTosource;
bTosource.BackEdge = sourceToB;
var AToB = new Edge
{
To = cityB,
Capacity = 3
};
var bToA = new Edge
{
To = cityA,
Capacity = 3
};
AToB.BackEdge = bToA;
bToA.BackEdge = AToB;
var AToEnd = new Edge
{
To = end,
Capacity = 4
};
var endToA = new Edge
{
To = cityA,
Capacity = 4
};
AToEnd.BackEdge = endToA;
endToA.BackEdge = AToEnd;
var BToEnd = new Edge
{
To = end,
Capacity = 5
};
var endToB = new Edge
{
To = cityB,
Capacity = 5
};
BToEnd.BackEdge = endToB;
endToB.BackEdge = BToEnd;
source.Edges.Add(sourceToA);
source.Edges.Add(sourceToB);
cityA.Edges.Add(AToB);
cityA.Edges.Add(AToEnd);
cityA.Edges.Add(aToSource);
cityB.Edges.Add(BToEnd);
cityB.Edges.Add(bToA);
cityB.Edges.Add(bTosource);
end.Edges.Add(endToA);
end.Edges.Add(endToB);
var comparer = new StrComparer();
tree = new AVLTree <string, Node>(comparer);
tree.Insert(source.Name, source);
tree.Insert(cityA.Name, cityA);
tree.Insert(cityB.Name, cityB);
tree.Insert(end.Name, end);
}
public void TestAvlTrees()
{
tree = new AVLTree <string, string>();
ExecuteTestTree();
tree.Clear();
}
public void ContainsTest(AVLTree <int> actualTree, int parameter, bool expected)
{
bool actual = actualTree.Contains(parameter);
Assert.AreEqual(expected, actual);
}
public void TestSerializeClassAvlTree()
{
Console.WriteLine("Building Class AVLTree...");
AVLTree <Person, Couple> tree = new AVLTree <Person, Couple>();
int count = 1000;
for (int i = 0; i < count; i++)
{
Person a = new Person()
{
age = i, name = "a" + i
};
Person b = new Person()
{
age = i, name = "b" + i
};
Couple c = new Couple()
{
man = a, woman = b
};
tree.Add(a, c);
tree.Add(b, c);
}
Console.WriteLine("Serializing...");
Serializer.WriteXmlData(tree, "tree");
Console.WriteLine("Deserializing...");
tree = Serializer.ReadXmlData <AVLTree <Person, Couple> >("tree");
Console.WriteLine("Validating...");
for (int i = 0; i < count; i++)
{
Assert.IsTrue(tree[new Person()
{
age = i, name = "a" + i
}].woman.Equals(new Person()
{
age = i, name = "b" + i
}));
Assert.IsTrue(tree[new Person()
{
age = i, name = "b" + i
}].woman.Equals(new Person()
{
age = i, name = "b" + i
}));
Assert.IsTrue(tree[new Person()
{
age = i, name = "a" + i
}].man.Equals(new Person()
{
age = i, name = "a" + i
}));
Assert.IsTrue(tree[new Person()
{
age = i, name = "b" + i
}].man.Equals(new Person()
{
age = i, name = "a" + i
}));
}
}
/// <summary>
/// Загрузка данных из файла приложения.
/// </summary>
/// <param name="tickets">Список авиабилетов.</param>
/// <param name="passengers">Список пассажиров.</param>
/// <param name="flights">Список авиарейсов.</param>
public static void Load(List <Ticket> tickets, HashTable <Passenger> passengers, AVLTree <Flight> flights)
{
if (File.Exists(file_name))
{
using (StreamReader sr = new StreamReader(file_name))
{
string s = sr.ReadLine(); // Ticket Section
s = sr.ReadLine();
while (s != "Passenger Section")
{
var array = s.Split('&');
var ticket = new Ticket(array[0], array[1]);
if (array[2] != "")
{
ticket.Passport = array[2];
}
tickets.Add(ticket);
s = sr.ReadLine();
}
tickets.Sort();
s = sr.ReadLine(); //Passenger Section
while (s != "Flight Section")
{
var array = s.Split('&');
var passenger = new Passenger()
{
Passport = array[0],
PlaceAndDate = array[1],
FIO = array[2],
Birthday = array[3]
};
passengers.Add(passenger.Passport, passenger);
s = sr.ReadLine();
}
s = sr.ReadLine(); //Flight Section
while (s != null)
{
var array = s.Split('&');
var flight = new Flight()
{
Number = array[0],
Airline = array[1],
DeparturesAirport = array[2],
ArrivalAirport = array[3],
DeparturesDate = array[4],
DeparturesTime = array[5],
NumberOfSeatsAll = uint.Parse(array[6]),
NumberOfSeatsFree = uint.Parse(array[7])
};
flights.Add(flight.Number, flight);
s = sr.ReadLine();
}
}
}
}
public void AddingAfterRemovingAllElements()
{
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();
}
//Removing 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)
{
tree.Remove(el);
el += i;
}
}
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 SortedSet(IComparer <T> comparer)
{
_comparer = comparer ?? Comparer <T> .Default;
_wrapped = new AVLTree <T, T>(_comparer);
}
public SortedSet()
{
_comparer = Comparer <T> .Default;
_wrapped = new AVLTree <T, T>();
}
private CommunityModel()
{
Communities = new AVLTree <Community>();
Users = new ListDirectedGraph <User>();
}
public void Setup()
{
empty_tree = new AVLTree();
/**
* 0
*/
only_root = new AVLTree();
only_root.root = new Node(0);
/**
* 2
* \
* 5
*/
two_nodes = new AVLTree();
two_nodes.root = new Node(2);
two_nodes.root.right = new Node(5);
/**
* 10
* /
* 5
* \
* 7
*/
three_nodes_unbalanced = new AVLTree();
three_nodes_unbalanced.root = new Node(10);
three_nodes_unbalanced.root.left = new Node(5);
three_nodes_unbalanced.root.left.right = new Node(7);
/** 8
* / \
* 5 11
* / \ / \
* 3 7 10 12
* / \ / /
* 2 4 6 9
* /
* 1
*/
big_tree_balanced = new AVLTree();
big_tree_balanced.root = new Node(8);
big_tree_balanced.root.left = new Node(5);
big_tree_balanced.root.left.left = new Node(3);
big_tree_balanced.root.left.left.left = new Node(2);
big_tree_balanced.root.left.left.left.left = new Node(1);
big_tree_balanced.root.left.left.right = new Node(4);
big_tree_balanced.root.left.right = new Node(7);
big_tree_balanced.root.left.right.left = new Node(6);
big_tree_balanced.root.right = new Node(11);
big_tree_balanced.root.right.left = new Node(10);
big_tree_balanced.root.right.left.left = new Node(9);
big_tree_balanced.root.right.right = new Node(12);
/** 8
* / \
* 5 11
* / \ / \
* 3 7 10 12
* / \ /
* 2 4 6
* /
* 1
*/
big_tree_unbalanced = new AVLTree();
big_tree_unbalanced.root = new Node(8);
big_tree_unbalanced.root.left = new Node(5);
big_tree_unbalanced.root.left.left = new Node(3);
big_tree_unbalanced.root.left.left.left = new Node(2);
big_tree_unbalanced.root.left.left.left.left = new Node(1);
big_tree_unbalanced.root.left.left.right = new Node(4);
big_tree_unbalanced.root.left.right = new Node(7);
big_tree_unbalanced.root.left.right.left = new Node(6);
big_tree_unbalanced.root.right = new Node(11);
big_tree_unbalanced.root.right.left = new Node(10);
big_tree_unbalanced.root.right.right = new Node(12);
}
public void AVLTreeInsert()
{
/**
* 4
*/
AVLTree one_insert = new AVLTree();
one_insert.insert(4);
Assert.AreEqual(4, one_insert.root.number);
/**
* 1
* \
* 2
*/
AVLTree two_inserts = new AVLTree();
two_inserts.insert(1);
two_inserts.insert(2);
Assert.AreEqual(1, two_inserts.root.number);
Assert.AreEqual(2, two_inserts.root.right.number);
/**
* The tree must have made a right
* rotation to keep it AVL balanced:
* 2
* / \
* 1 3
*/
AVLTree three_inserts = new AVLTree();
three_inserts.insert(1);
three_inserts.insert(2);
three_inserts.insert(3);
Assert.AreEqual(2, three_inserts.root.number);
Assert.AreEqual(1, three_inserts.root.left.number);
Assert.AreEqual(3, three_inserts.root.right.number);
/**
* Insert hundred ascending numbers
*/
AVLTree hundred_inserts = new AVLTree();
for (int i = 1; i <= 100; i++)
{
hundred_inserts.insert(i);
}
Assert.IsTrue(IsSorted(hundred_inserts.root));
Assert.LessOrEqual(GetDepth(hundred_inserts), 7);
/**
* Insert hundred descending numbers
*/
AVLTree hundred_inserts_descending = new AVLTree();
for (int i = 100; i >= 1; i--)
{
hundred_inserts_descending.insert(i);
}
Assert.IsTrue(IsSorted(hundred_inserts_descending.root));
Assert.LessOrEqual(GetDepth(hundred_inserts_descending), 7);
/**
* Insert hundred equal numbers
*/
AVLTree hundred_inserts_equal = new AVLTree();
for (int i = 0; i < 100; i++)
{
hundred_inserts_equal.insert(0);
}
Assert.IsTrue(IsSorted(hundred_inserts_equal.root));
Assert.LessOrEqual(GetDepth(hundred_inserts_equal), 7);
/**
* Insert thousand random numbers
*/
AVLTree thousand_inserts_random = new AVLTree();
Random f = new Random();
for (int i = 0; i < 1000; i++)
{
thousand_inserts_random.insert(f.Next(1, 1000));
}
Assert.IsTrue(IsSorted(thousand_inserts_random.root));
Assert.LessOrEqual(GetDepth(thousand_inserts_random), 12);
}
public TimelineModelBase()
{
this._statusIdCache = new AVLTree <long>();
this._statuses = new ObservableSynchronizedCollectionEx <StatusModel>();
}
public void Contains_Item_Test()
{
AVLTree <int> tree = InitAVLTree();
Assert.IsTrue(tree.Contains(3));
}
public void AVLTree_Accuracy_Test()
{
var nodeCount = 1000;
var rnd = new Random();
var sorted = Enumerable.Range(1, nodeCount).ToList();
var randomNumbers = sorted
.OrderBy(x => rnd.Next())
.ToList();
var tree = new AVLTree <int>(true);
for (int i = 0; i < nodeCount; i++)
{
tree.Insert(randomNumbers[i]);
Assert.IsTrue(tree.HasItem(randomNumbers[i]));
Assert.IsTrue(tree.Root.IsBinarySearchTree(int.MinValue, int.MaxValue));
tree.Root.VerifyCount();
var actualHeight = tree.GetHeight();
//http://stackoverflow.com/questions/30769383/finding-the-minimum-and-maximum-height-in-a-avl-tree-given-a-number-of-nodes
var maxHeight = 1.44 * Math.Log(nodeCount + 2, 2) - 0.328;
Assert.IsTrue(actualHeight < maxHeight);
Assert.IsTrue(tree.Count == i + 1);
}
for (int i = 0; i < sorted.Count; i++)
{
Assert.AreEqual(sorted[i], tree.ElementAt(i));
Assert.AreEqual(i, tree.IndexOf(sorted[i]));
}
randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
//IEnumerable test using linq
Assert.AreEqual(tree.Count, tree.Count());
Assert.AreEqual(tree.Count, tree.AsEnumerableDesc().Count());
for (int i = 0; i < nodeCount; i++)
{
if (rnd.NextDouble() >= 0.5)
{
tree.Delete(randomNumbers[i]);
}
else
{
var index = tree.IndexOf(randomNumbers[i]);
Assert.AreEqual(tree.ElementAt(index), randomNumbers[i]);
tree.RemoveAt(index);
}
Assert.IsTrue(tree.Root.IsBinarySearchTree(int.MinValue, int.MaxValue));
tree.Root.VerifyCount();
var actualHeight = tree.GetHeight();
//http://stackoverflow.com/questions/30769383/finding-the-minimum-and-maximum-height-in-a-avl-tree-given-a-number-of-nodes
var maxHeight = 1.44 * Math.Log(nodeCount + 2, 2) - 0.328;
Assert.IsTrue(actualHeight < maxHeight);
}
Assert.IsTrue(tree.Count == 0);
}
public void SetUp()
{
_avlTree = new AVLTree();
}
protected SortedSet(AVLTree <T, T> wrapped, IComparer <T> comparer)
{
_wrapped = wrapped ?? new AVLTree <T, T>();
_comparer = comparer ?? Comparer <T> .Default;
}
public void Rotation_Complexish()
{
AVLTree <int> tree = new AVLTree <int>();
// 3
// /
// 2
// /
// 1
tree.Add(3);
tree.Add(2);
tree.Add(1);
// 2
// / \
// 1 3
int[] expected = new[] { 2, 1, 3 };
int index = 0;
tree.PreOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order"));
Assert.AreEqual(index, expected.Length, "The wrong number of items were enumerated?");
// 2
// / \
// 1 3
// \
// 4
tree.Add(4);
expected = new[] { 2, 1, 3, 4 };
index = 0;
tree.PreOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order"));
Assert.AreEqual(index, expected.Length, "The wrong number of items were enumerated?");
// 2
// / \
// 1 3
// \
// 4
// \
// 5
tree.Add(5);
// 2
// / \
// 1 4
// / \
// 3 5
expected = new[] { 2, 1, 4, 3, 5 };
index = 0;
tree.PreOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order"));
Assert.AreEqual(index, expected.Length, "The wrong number of items were enumerated?");
// 2
// / \
// 1 4
// / \
// 3 5
// \
// 6
tree.Add(6);
// 4
// / \
// 2 5
// / \ \
// 1 3 6
expected = new[] { 4, 2, 1, 3, 5, 6 };
index = 0;
tree.PreOrderTraversal(item => Debug.WriteLine(item));
tree.PreOrderTraversal(item => Assert.AreEqual(expected[index++], item, "The item enumerated in the wrong order"));
Assert.AreEqual(index, expected.Length, "The wrong number of items were enumerated?");
}
AvlTreeNode <TNode> _right; // правый потомок
#region Конструктор
public AvlTreeNode(TNode value, AvlTreeNode <TNode> parent, AVLTree <TNode> tree)
{
Value = value;
Parent = parent;
_tree = tree;
}
/// <summary>
/// Сохранение данных в файл приложения.
/// </summary>
/// <param name="tickets">Список авиабилетов.</param>
/// <param name="passengers">Список пассажиров.</param>
/// <param name="flights">Список авиарейсов.</param>
public static void Save(List <Ticket> tickets, HashTable <Passenger> passengers, AVLTree <Flight> flights)
{
using (StreamWriter sw = new StreamWriter(file_name, false))
{
sw.WriteLine("Ticket Section");
foreach (var el in tickets)
{
string[] ticket = new string[3];
ticket[0] = el.Number;
ticket[1] = el.Flight;
ticket[2] = el.Passport;
sw.WriteLine(string.Join("&", ticket));
}
sw.WriteLine("Passenger Section");
foreach (var el in passengers)
{
string[] passenger = new string[4];
passenger[0] = el.Passport;
passenger[1] = el.PlaceAndDate;
passenger[2] = el.FIO;
passenger[3] = el.Birthday;
sw.WriteLine(string.Join("&", passenger));
}
sw.WriteLine("Flight Section");
foreach (var el in flights)
{
string[] flight = new string[8];
flight[0] = el.Number;
flight[1] = el.Airline;
flight[2] = el.DeparturesAirport;
flight[3] = el.ArrivalAirport;
flight[4] = el.DeparturesDate;
flight[5] = el.DeparturesTime;
flight[6] = el.NumberOfSeatsAll.ToString();
flight[7] = el.NumberOfSeatsFree.ToString();
sw.WriteLine(string.Join("&", flight));
}
}
}
public void LargeTreeTest()
{
var avl = new AVLTree <int, int> {
{ 4, 0 }, { 8, 0 }, { 12, 0 }, { 16, 0 }, { 18, 0 }, { 19, 0 }, { 21, 0 }
};
Assert.AreEqual(avl.Count, 7);
var expected = new[] { 4, 8, 12, 16, 18, 19, 21 };
var index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(2, 0);
avl.Add(6, 0);
avl.Add(10, 0);
avl.Add(14, 0);
avl.Add(17, 0);
avl.Add(20, 0);
avl.Add(22, 0);
expected = new[] { 2, 4, 6, 8, 10, 12, 14, 16, 17, 18, 19, 20, 21, 22 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(1, 0);
avl.Add(3, 0);
avl.Add(5, 0);
avl.Add(7, 0);
avl.Add(9, 0);
avl.Add(11, 0);
avl.Add(13, 0);
avl.Add(15, 0);
avl.Add(23, 0);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Remove(23);
avl.Remove(20);
avl.Remove(17);
avl.Remove(22);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 21 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(9, 0);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 21 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(31, 0);
avl.Add(27, 0);
avl.Add(26, 0);
avl.Add(24, 0);
avl.Add(28, 0);
avl.Add(30, 0);
avl.Add(32, 0);
avl.Add(29, 0);
avl.Add(25, 0);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Remove(31);
avl.Remove(30);
avl.Remove(25);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 21, 24, 26, 27, 28, 29, 32 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(20, 0);
avl.Add(10, 0);
avl.Add(30, 0);
avl.Add(35, 0);
avl.Add(31, 0);
avl.Add(33, 0);
avl.Add(32, 0);
avl.Add(34, 0);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21, 24, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 35 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(39, 0);
avl.Add(36, 0);
avl.Add(46, 0);
avl.Add(42, 0);
avl.Add(38, 0);
avl.Add(29, 0);
avl.Add(21, 0);
avl.Add(48, 0);
avl.Add(44, 0);
avl.Add(40, 0);
avl.Add(47, 0);
avl.Add(49, 0);
avl.Add(41, 0);
avl.Add(1, 0);
avl.Add(28, 0);
avl.Add(7, 0);
avl.Add(43, 0);
avl.Add(45, 0);
avl.Add(37, 0);
expected = new[] { 1, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 9, 10, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21, 21, 24, 26, 27, 28, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Remove(1);
avl.Remove(7);
avl.Remove(9);
avl.Remove(10);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21, 21, 24, 26, 27, 28, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(17, 0);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 21, 24, 26, 27, 28, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Remove(21);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 26, 27, 28, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(22, 0);
avl.Add(23, 0);
avl.Add(25, 0);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Remove(28);
avl.Remove(29);
avl.Remove(32);
expected = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
avl.Add(50, 0);
avl.Add(51, 0);
avl.Add(52, 0);
avl.Add(53, 0);
avl.Add(54, 0);
avl.Add(55, 0);
avl.Add(56, 0);
avl.Add(57, 0);
avl.Add(58, 0);
avl.Add(59, 0);
avl.Add(60, 0);
avl.Add(61, 0);
avl.Add(62, 0);
avl.Add(63, 0);
avl.Add(64, 0);
avl.Add(65, 0);
avl.Add(66, 0);
avl.Add(67, 0);
avl.Add(68, 0);
avl.Add(69, 0);
avl.Add(70, 0);
avl.Add(71, 0);
avl.Add(72, 0);
avl.Add(73, 0);
avl.Add(74, 0);
avl.Add(75, 0);
avl.Add(76, 0);
avl.Add(77, 0);
avl.Add(78, 0);
avl.Add(79, 0);
avl.Add(80, 0);
avl.Add(81, 0);
avl.Add(82, 0);
avl.Add(83, 0);
avl.Add(84, 0);
avl.Add(85, 0);
avl.Add(86, 0);
avl.Add(87, 0);
avl.Add(88, 0);
avl.Add(89, 0);
avl.Add(90, 0);
avl.Add(91, 0);
avl.Add(92, 0);
avl.Add(93, 0);
avl.Add(94, 0);
avl.Add(95, 0);
avl.Add(96, 0);
avl.Add(97, 0);
avl.Add(98, 0);
avl.Add(99, 0);
avl.Add(0, 0);
expected = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 };
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
}
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 AddRemoveAndBalanceDuplicates()
{
var values = new[]
{
9,
77,
50,
48,
24,
60,
72,
95,
66,
27,
28,
33,
50,
65,
37,
75,
58,
36,
74,
60
};
var avl = new AVLTree <int, int>();
var expected = new List <int>();
var duplicates = new List <int>();
foreach (var item in values)
{
bool duplicate = expected.Contains(item);
if (duplicate)
{
duplicates.Add(item);
}
else
{
expected.Add(item);
}
avl.Add(item, item);
}
foreach (var duplicate in duplicates)
{
Assert.IsTrue(avl.Remove(duplicate));
}
Assert.AreEqual(expected.Count, avl.Count);
expected.Sort();
var index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
foreach (var duplicate in duplicates)
{
Assert.IsTrue(avl.Remove(duplicate));
expected.Remove(duplicate);
}
Assert.AreEqual(expected.Count, avl.Count);
expected.Sort();
index = 0;
foreach (var item in avl)
{
Assert.AreEqual(expected[index], item.Key);
index++;
}
}
public void ClearTest(AVLTree <int> actualTree, AVLTree <int> expected)
{
actualTree.Clear();
CollectionAssert.AreEqual(expected, actualTree);
}
private SortedSet(AVLTree <T, VoidStruct> wrapped, IComparer <T> comparer)
{
_wrapped = wrapped ?? new AVLTree <T, VoidStruct>();
Comparer = comparer ?? Comparer <T> .Default;
}
public SortedSet(IComparer <T> comparer)
{
Comparer = comparer ?? Comparer <T> .Default;
_wrapped = new AVLTree <T, VoidStruct>(Comparer);
}
public SortedSet()
{
Comparer = Comparer <T> .Default;
_wrapped = new AVLTree <T, VoidStruct>();
}
public void AVLTree_Smoke_Test()
{
//insert test
var tree = new AVLTree <int>();
Assert.AreEqual(-1, tree.GetHeight());
tree.Insert(1);
Assert.AreEqual(0, tree.GetHeight());
tree.Insert(2);
Assert.AreEqual(1, tree.GetHeight());
tree.Insert(3);
Assert.AreEqual(1, tree.GetHeight());
tree.Insert(4);
Assert.AreEqual(2, tree.GetHeight());
tree.Insert(5);
Assert.AreEqual(2, tree.GetHeight());
tree.Insert(6);
Assert.AreEqual(2, tree.GetHeight());
tree.Insert(7);
Assert.AreEqual(2, tree.GetHeight());
tree.Insert(8);
Assert.AreEqual(3, tree.GetHeight());
tree.Insert(9);
Assert.AreEqual(3, tree.GetHeight());
tree.Insert(10);
Assert.AreEqual(3, tree.GetHeight());
tree.Insert(11);
Assert.AreEqual(3, tree.GetHeight());
//IEnumerable test using linq
Assert.AreEqual(tree.Count, tree.Count());
//delete
tree.Delete(1);
Assert.AreEqual(3, tree.GetHeight());
tree.Delete(2);
Assert.AreEqual(3, tree.GetHeight());
tree.Delete(3);
Assert.AreEqual(3, tree.GetHeight());
tree.Delete(4);
Assert.AreEqual(2, tree.GetHeight());
tree.Delete(5);
Assert.AreEqual(2, tree.GetHeight());
tree.Delete(6);
Assert.AreEqual(2, tree.GetHeight());
tree.Delete(7);
Assert.AreEqual(2, tree.GetHeight());
tree.Delete(8);
Assert.AreEqual(1, tree.GetHeight());
tree.Delete(9);
Assert.AreEqual(1, tree.GetHeight());
tree.Delete(10);
Assert.AreEqual(0, tree.GetHeight());
tree.Delete(11);
Assert.AreEqual(tree.GetHeight(), -1);
Assert.AreEqual(tree.Count, 0);
tree.Insert(31);
}
public FieldSide()
{
FieldWall = new FieldWall();
SideLanes = new AVLTree <SideLane>(p => p.ValidRange.StartTick);
}
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
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
int[] arr = { 1, 2, 3, 3, 4, 5, 5, 8, 10, 10 };
//var a = BubbleSort.GetSorted(arr);
// QuickSort.GetSorted(arr);
MyHeap.BuildHead();
//foreach (var x in a)
//{
// Console.WriteLine(x);
//}
var a = removeDuplicates(arr, arr.Length);
// Print updated array
for (int i = 0; i < a; i++)
{
Console.Write(arr[i] + " ");
}
var b = BianrySearch(arr, 225, 0, arr.Length - 1);
Console.WriteLine(b);
BinaryTree bt = new BinaryTree();
BinaryTree bt1 = new BinaryTree();
var root = bt.Insert(null, 10);
var root1 = bt1.Insert(null, 10);
/*root = bt.Insert(root, 20);
* root = bt.Insert(root, 8);
* root = bt.Insert(root, 9);
* root = bt.Insert(root, 15);
* root = bt.Insert(root, 25);
*/
bt.Insert(root, 20);
bt.Insert(root, 8);
bt.Insert(root, 9);
bt.Insert(root, 15);
bt.Insert(root, 25);
bt.Insert(root, 12);
bt.Insert(root, 5);
bt1.Insert(root1, 20);
bt1.Insert(root1, 8);
bt1.Insert(root1, 9);
bt1.Insert(root1, 15);
bt1.Insert(root1, 25);
//bt1.Insert(root1, 12);
bt1.Insert(root1, 7);
TwoNodes tn = new TwoNodes {
First = bt.RootNode, Second = bt1.RootNode
};
Console.WriteLine("Is_BST_Identical_Iterative ::{0} ", bt.Is_BST_Identical_Iterative(tn));
Console.WriteLine("Is_BST_Identical ::{0} ", bt.isIdentical(bt.RootNode, bt1.RootNode));
bt1.Height_Tree_Iterative(bt1.RootNode);
Console.WriteLine("PreOrder");
bt.PreOrder(bt.RootNode);
Console.WriteLine("");
Console.WriteLine("InOrder");
bt.InOrder(bt.RootNode);
Console.WriteLine("");
Console.WriteLine("PostOrder");
bt.PostOrder(bt.RootNode);
bt.CreateBinaryTreeFromInAndPreOrder();
Console.WriteLine("");
Console.WriteLine("Find");
var f = bt.Find(115, bt.RootNode);
Console.WriteLine(f != null ? f.data : 0);
Console.WriteLine("");
Console.WriteLine("MinValue");
var m = bt.GetMinValue(bt.RootNode);
Console.WriteLine(m);
int pos = 6;
bt.GetKthMinValue(bt.RootNode, ref pos);
//bt.LevelOrder(bt.RootNode);
//bt.Inorder_Iterative(bt.RootNode);
//bt.Preorder_Iterative(bt.RootNode);
//bt.Postorder_Iterative(bt.RootNode);
//bt.Get_Inorder_Predecessor(bt.RootNode);
//bt.Get_Inorder_Successor(bt.RootNode);
Console.WriteLine("\nInvert binary");
bt.InvertBinary(bt.RootNode);
bt.LevelOrder(bt.RootNode);
Node ln = new Node {
data = 20
};
Node rn = new Node {
data = 30
};
Node no = new Node {
data = 10, Left = ln, Right = rn
};
// Console.WriteLine("isBST :: {0}", bt.isBST(no, int.MinValue) );
Console.WriteLine("isBST :: {0}", bt.isBinarySearch(no));
AVLTree at = new AVLTree();
at.Avl_execute();
int[] arr1 = { 5, 6, 8, 9, 10, 12, 15, 20 };
GetTriplets(arr1, 30);
GetSumDobles(arr1, 15);
GetSumDobles_Linear(arr1, 15);
Console.WriteLine("KnapSack");
int[] val = new int[] { 60, 120, 100 };
int[] wt = new int[] { 10, 30, 20 };
int Cap = 50;
int n = val.Length;
int[,] dp = new int[n + 1, Cap + 1];
KnapSack k = new KnapSack();
Console.WriteLine(k.KnapSack_Binary(Cap, wt, val, n, dp));
k.KnapSack_Fraction(Cap, wt, val, n);
Console.WriteLine("Pattern");
Pattern.SearchPattern("AABAACAADAABAAABAACAAD", "CAAD");
Pattern.Binary_MultipleOf3("110100000101");
Console.WriteLine("Largest Sum Contiguous Subarray");
int[] aa = { 1, 2, 3, -2, 5 };
Pattern.maxSubArraySum(aa);
Console.WriteLine("Missing elements");
int[] aa1 = { 1, 2, 3, 5, 7, 8, 10 };
Pattern.FindMissingElements(aa1);
int[] aa2 = { 1, 2, 3, 1, 1 };
Pattern.FindMajorityElement(aa2);
//Search in a Rotated Array
int[] aa3 = { 5, 6, 7, 8, 9, 10, 1, 2, 3, 4 };
Pattern.SearchRotatedArray(aa3, 10);
//Linked List
LinkedList lst = new LinkedList();
lst.InsertFront(10);
lst.InsertLast(20);
lst.InsertFront(5);
lst.InsertLast(25);
lst.InsertLast(35);
lst.PrintList(lst);
lst.FindMiddleElement(lst);
Problem_30 p30 = new Problem_30();
p30.FindSingeNumber();
p30.HappyNumber();
p30.Longest_Sum_Subarray();
p30.FindSubarraySum();
p30.MoveZeroRight();
p30.MaxProfit();
p30.IsAnagram();
p30.StringSorting("kgadeA");
p30.GroupingAnagrams();
p30.CountingElement();
p30.BackspaceStingCompare();
//p30.LastStoneWeight();
p30.SubArrayWithEqualZeroAndOne();
p30.StringShif();
p30.ProductOfArrayExceptSlef();
Console.WriteLine("\nValid parenthesis:: {0}", p30.ValidParenthesis());
p30.NumberOfIsland();
p30.LeftmostColumnWithAtleastOne();
p30.BitwiseAnd();
p30.JumpingProblem();
p30.LongestcommonSubsequence();
p30.CountPairsGivenSum();
p30.MaximumPathSum(bt.RootNode);
p30.ValidSequence(bt.RootNode);
p30.MinFromSatck();
p30.MinimumPathSum();
p30.HistogramMaxRectangle();
//p30.Print_Combination_R_Elements_Array();
///All Array Problem
///
ArrayProblem ar = new ArrayProblem();
ar.Find_And_Print_SubArraySum();
ar.SortBinaryArray();
ar.FindDuplicate();
ar.LongestConsecutiveSubArray();
ar.MaximumSumSubArray();
ar.MinimuSumSubArray();
ar.SubArrayWithEqualZeroAndOne();
ar.SortArrayOnlyZeroOneTwos();
ar.Merge2SortedArray();
ar.MergeArray_ReplaceZeroValue();
ar.Find_Index_MaxLength_ContinuousOnes();
ar.ProductOfTwoIntArray();
ar.Suffle();
ar.RearrangeArrayHighAndLow();
ar.EquilibriumIndex();
ar.FindMajorityElement();
ar.MoveAllZeroToEnd();
ar.ProductOfArrayWithotSlef();
ar.BitonicSubArray();
ar.FindMaximumDifference();
ar.MaximumSumCircularSubArray();
ar.FindSumMimumSubArray_Given_Size();
ar.FindSumSubArray_Given_Sum();
ar.LengthOfSmallestSubarray_SumOfElements_GreaterThanNumber();
ar.Find_Smallest_Window_Will_Make_Entire_Array_Sorted();
ar.TrappingRainWaterwithin_given_set_bars();
ar.Find_Maximum_Sum_Subsequence_With_NO_Adjacent();
ar.MinimumNumber_Platform();
ar.LengthOf_Continuous_Same_Sum_Two_Binary_Array();
ar.Find_Number_Rotations();
ar.RodCutting();
ar.Find_kth_Smallest_Element();
ar.FindAllCombinations();
//Trie data structure
Trie tr = new Trie();
string[] words = { "abc", "abgl", "cdf", "abcd", "lmn" };
//string[] words = { "abc"};
foreach (string st in words)
{
tr.Insert(st);
}
Console.WriteLine("\nIs string present {0} ", tr.Search("cdf"));
tr.AutoComplete("ab");
// List of graph edges as per above diagram
List <Edge> edges = new List <Edge> {
// Notice that node 0 is unconnected node
new Edge(1, 2), new Edge(1, 7), new Edge(1, 8),
new Edge(2, 3), new Edge(2, 6), new Edge(3, 4),
new Edge(3, 5), new Edge(8, 9), new Edge(8, 12),
new Edge(9, 10), new Edge(9, 11)
};
// Set number of vertices in the graph (0-12)
int N = 13;
// create a graph from edges
Graph graph = new Graph(edges, N);
// stores vertex is discovered or not
bool[] discovered = new bool[N];
// Do DFS traversal from all undiscovered nodes to
// cover all unconnected components of graph
for (int i = 0; i < N; i++)
{
if (!discovered[i])
{
graph.DFS(graph, i, discovered);
}
}
//Matrix
Matrix mt = new Matrix();
mt.Print_SpiralOrder();
mt.Rotation_90();
mt.FloodFill();
}
