public void AvlTree_AddRotateLeft_Test() { Func <int, int, bool> Smaller = (a, b) => { return(a < b); }; AvlTree <int> Tree = new AvlTree <int>(Smaller); AvlTree <int> .NodeCheck _2 = AvlTree <int> .NodeCheck.ConvirmValue(2), _1 = AvlTree <int> .NodeCheck.ConvirmValue(1), _4 = AvlTree <int> .NodeCheck.ConvirmValue(4), _3 = AvlTree <int> .NodeCheck.ConvirmValue(3), _5 = AvlTree <int> .NodeCheck.ConvirmValue(5); _2.NextCheck = _1; _1.NextCheck = _4; _4.NextCheck = _3; _3.NextCheck = _5; Tree.Add(1); Tree.Add(2); Tree.Add(3); Tree.Add(4); Tree.Add(5); //Tree.Dump(); Tree.HierarchyCheck(_2); }
public void Add_LeftRotationOnLeftChild() { var tree = new AvlTree <int>(); tree.Add(50); tree.Add(30); tree.Add(60); tree.Add(20); tree.Add(40); tree.Add(55); tree.Add(65); tree.Add(10); tree.Add(25); tree.Add(5); Assert.Equal(50, tree.Root.Value); Assert.Equal(20, tree.Root.Left.Value); Assert.Equal(10, tree.Root.Left.Left.Value); Assert.Equal(5, tree.Root.Left.Left.Left.Value); Assert.Null(tree.Root.Left.Left.Right); Assert.Equal(30, tree.Root.Left.Right.Value); Assert.Equal(25, tree.Root.Left.Right.Left.Value); Assert.Equal(40, tree.Root.Left.Right.Right.Value); Assert.Equal(60, tree.Root.Right.Value); Assert.Equal(55, tree.Root.Right.Left.Value); Assert.Equal(65, tree.Root.Right.Right.Value); AssertBalanced(tree); AssertOrdered(tree); }
public void Add_RightRotation() { var tree = new AvlTree <int>(); tree.Add(2); tree.Add(3); tree.Add(4); Assert.Equal(3, tree.Root.Value); Assert.Equal(2, tree.Root.Left.Value); Assert.Equal(4, tree.Root.Right.Value); tree.Add(5); Assert.Equal(3, tree.Root.Value); Assert.Equal(2, tree.Root.Left.Value); Assert.Equal(4, tree.Root.Right.Value); Assert.Equal(5, tree.Root.Right.Right.Value); tree.Add(6); Assert.Equal(3, tree.Root.Value); Assert.Equal(2, tree.Root.Left.Value); Assert.Equal(5, tree.Root.Right.Value); Assert.Equal(4, tree.Root.Right.Left.Value); Assert.Equal(6, tree.Root.Right.Right.Value); AssertBalanced(tree); AssertOrdered(tree); }
public void AddTwoElementSecondIsGreaterFirst() { var tree = new AvlTree <int, int>(); tree.Add(0, 0); tree.Add(1, 0); Assert.AreEqual("0 0\n1 0\n", tree.Print()); }
public void AddTwoElementSecondIsLessFirst() { var tree = new AvlTree <int, int>(); tree.Add(0, 0); tree.Add(-1, 0); Assert.AreEqual("-1 0\n0 0\n", tree.Print()); }
public void CountAfterAdding() { var tree = new AvlTree <int, int>(); tree.Add(0, 0); tree.Add(1, 0); Assert.AreEqual(2, tree.Count); }
public void TestAddInOrder() { var tree = new AvlTree<TestNode> (); tree.Add (new TestNode (1)); tree.Add (new TestNode (2)); tree.Add (new TestNode (3)); Assert.AreEqual (3, tree.Count); Assert.AreEqual ("1,2,3,", GetContent (tree)); }
public void TestAddOutOfOrder() { var tree = new AvlTree <TestNode> (); tree.Add(new TestNode(3)); tree.Add(new TestNode(1)); tree.Add(new TestNode(2)); Assert.AreEqual(3, tree.Count); Assert.AreEqual("1,2,3,", GetContent(tree)); }
public void InsertAndRebalance3ItemsTest() { AvlTree <int> newTree = new AvlTree <int>(); newTree.Add(25); newTree.Add(12); newTree.Add(14); Assert.AreEqual(14, newTree.Root.Data); }
public void GeeksForGeeks_TreeConstructionAndRemoval() { //Arrange var avl = new AvlTree <int, string>(); avl.Add(9, "9"); avl.Add(5, "5"); avl.Add(10, "10"); avl.Add(0, "0"); avl.Add(6, "6"); avl.Add(11, "11"); avl.Add(-1, "-1"); avl.Add(1, "1"); avl.Add(2, "2"); //Act var result = avl.Remove(10); var tree = avl._root; //Assert Assert.True(result); Assert.Equal(1, tree.Key); Assert.Equal(9, tree.Right.Key); Assert.Equal(0, tree.Left.Key); Assert.Equal(11, tree.Right.Right.Key); Assert.Equal(5, tree.Right.Left.Key); Assert.Equal(6, tree.Right.Left.Right.Key); Assert.Equal(2, tree.Right.Left.Left.Key); Assert.Equal(-1, tree.Left.Left.Key); }
public void RemoveTest() { var tree = new AvlTree <int>(); tree.Add(30); tree.Add(20); tree.Add(40); tree.Add(10); tree.Add(25); tree.Add(35); tree.Add(50); tree.Add(24); tree.Add(26); tree.Remove(20); Assert.Equal(30, tree.Root.Value); Assert.Equal(40, tree.Root.Right.Value); Assert.Equal(35, tree.Root.Right.Left.Value); Assert.Equal(50, tree.Root.Right.Right.Value); Assert.Equal(24, tree.Root.Left.Value); Assert.Equal(10, tree.Root.Left.Left.Value); Assert.Equal(25, tree.Root.Left.Right.Value); Assert.Null(tree.Root.Left.Right.Left); Assert.Equal(26, tree.Root.Left.Right.Right.Value); }
public void TreeConstruction() { //Arrange var avl = new AvlTree <int, string>(); avl.Add(9, "9"); avl.Add(5, "5"); avl.Add(10, "10"); avl.Add(0, "0"); avl.Add(6, "6"); avl.Add(11, "11"); avl.Add(-1, "-1"); avl.Add(1, "1"); avl.Add(2, "2"); //Act var result = avl._root; //Assert Assert.Equal(9, result.Key); Assert.Equal(10, result.Right.Key); Assert.Equal(1, result.Left.Key); Assert.Equal(11, result.Right.Right.Key); Assert.Equal(5, result.Left.Right.Key); Assert.Equal(6, result.Left.Right.Right.Key); Assert.Equal(2, result.Left.Right.Left.Key); Assert.Equal(0, result.Left.Left.Key); Assert.Equal(-1, result.Left.Left.Left.Key); }
public void ShouldBalanceTreeWhenItIsLeftRightOverweight() { var avlTree = new AvlTree<int>(40); avlTree.Add(15); avlTree.Add(25); Assert.AreEqual(25, avlTree.Root.Value); Assert.AreEqual(15, avlTree.Root.LeftChild.Value); Assert.AreEqual(40, avlTree.Root.RightChild.Value); }
public void ShouldBalanceTreeWhenItIsLeftRightOverweight() { var avlTree = new AvlTree <int>(40); avlTree.Add(15); avlTree.Add(25); Assert.AreEqual(25, avlTree.Root.Value); Assert.AreEqual(15, avlTree.Root.LeftChild.Value); Assert.AreEqual(40, avlTree.Root.RightChild.Value); }
public void LeftRightRotationNoChildrenRootChangeTest() { AvlTree <int> avl = new AvlTree <int>(null); avl.Add(30); avl.Add(10); avl.Add(20); Assert.AreEqual(20, avl.Root.Data); Assert.AreEqual(30, avl.Root.Right.Data); Assert.AreEqual(10, avl.Root.Left.Data); }
public void RemoveWithAncestorNoRotationTest() { AvlTree <int> avl = new AvlTree <int>(null); avl.Add(5); avl.Add(6); avl.Add(2); avl.Add(1); avl.RemoveNode(2); Assert.AreEqual(2, avl.Root.Left.Data); }
public void RemoveTest() { const int rootKey = 4; const int removeKey = 3; var tree = new AvlTree(); tree.Add(rootKey); tree.Add(removeKey); tree.Remove(removeKey); Assert.IsTrue(tree.Root == rootKey, "Deleted node with wrong key"); }
public void RemoveWithoutRebalanceTest() { AvlTree <int> avl = new AvlTree <int>(null); avl.Add(40); avl.Add(50); avl.Add(30); avl.RemoveNode(50); avl.RemoveNode(30); Assert.AreEqual(40, avl.Root.Data); Assert.IsNull(avl.Root.Left); Assert.IsNull(avl.Root.Right); }
public static void Main() { AvlTree <int> avl = new AvlTree <int>(null); avl.Add(20); avl.Add(10); avl.Add(30); avl.Add(40); avl.Add(50); Console.WriteLine("Asi sa nic nepokazilo"); Console.ReadKey(); }
public void CreateBalancedTree1() { var tree = new AvlTree <int>(); tree.Add(1); tree.Add(2); tree.Add(3); Assert.Equal(2, tree.Root.Value); tree.Add(6); Assert.Equal(2, tree.Root.Value); tree.Add(15); Assert.Equal(2, tree.Root.Value); tree.Add(-2); Assert.Equal(2, tree.Root.Value); tree.Add(-5); Assert.Equal(2, tree.Root.Value); tree.Add(-8); Assert.Equal(2, tree.Root.Value); AssertBalanced(tree); AssertOrdered(tree); }
public void RightLeftRotation1() { var tree = new AvlTree <int>(); tree.Add(30); tree.Add(40); tree.Add(35); Assert.Equal(35, tree.Root.Value); Assert.Equal(30, tree.Root.Left.Value); Assert.Equal(40, tree.Root.Right.Value); AssertBalanced(tree); AssertOrdered(tree); }
public void InOrderTraversTest() { var tree = new AvlTree(); tree.Add(4); tree.Add(3); tree.Add(5); tree.Add(7); var result = tree.InOrderTravers(); var expectedResult = new[] { 3, 4, 5, 7 }; Assert.IsTrue(result.SequenceEqual(expectedResult), "The tree traver is wrong"); }
public void Add_KeyAlreadyInTree_ThrowsException() { var tree = new AvlTree <int>(); tree.AddRange(new[] { 1, 2, 3, 4, 5 }); Assert.Throws <ArgumentException>(() => tree.Add(1)); }
/// <summary>Loads a shader file, compiles it on the GPU, and adds it to the database.</summary> /// <param name="shaderId">The name you want to associate with this specific shader so you can use it later.</param> /// <param name="filePath">The file location of the shader file.</param> /// <returns>If the load was successful. (true if successful; false if unsuccessful)</returns> public static bool LoadExtendedGeometryShader(string shaderId, string filePath) { // Store the entire file in a string to be compiled on the GPU. string shaderSource; using (StreamReader reader = new StreamReader(filePath)) { shaderSource = reader.ReadToEnd(); } // Attempt to load the shader on the GPU and compile it int shaderHandle; shaderHandle = GL.CreateShader(ShaderType.GeometryShaderExt); GL.ShaderSource(shaderHandle, shaderSource); GL.CompileShader(shaderHandle); // Check for compiler errors string[] filePathSplit = filePath.Split('\\'); string compilationError = GL.GetShaderInfoLog(shaderHandle); if (compilationError == "" || compilationError == "No errors\n") { Output.WriteLine("ERROR loading shader \"" + filePathSplit[filePathSplit.Length - 1] + "\";"); Output.WriteLine(compilationError); return(false); } // The load and comilation was successful, we can add it to the database. _extendedGeometryShaderDatabase.Add(new ExtendedGeometryShader(shaderId, filePath, shaderHandle)); Output.WriteLine("Shader file compiled \"" + filePathSplit[filePathSplit.Length - 1] + "\";"); return(true); }
public void AddOneElement() { var tree = new AvlTree <int, int>(); tree.Add(0, 0); Assert.AreEqual("0 0\n", tree.Print()); }
public void InsertionAndDeletionPUT([PexAssumeUnderTest] List <int> values, int start, int end) { PexAssume.IsFalse(start < 0 || end < 0); PexAssume.IsTrue(start < values.Count); PexAssume.IsTrue(end >= start && end < values.Count); PexAssume.AreDistinctValues <int>(values.ToArray()); AvlTree <int> avlTree = new AvlTree <int>(); foreach (int i in values) { avlTree.Add(i); } PexAssert.AreEqual(values.Count, avlTree.Count); PexObserve.ValueForViewing <int>("Root", avlTree.Root.Value); int toRemoveCount = (end - start) == 0?1:end - start; IList <int> toRemove = values.GetRange(start, toRemoveCount); foreach (int i in toRemove) { avlTree.Remove(i); } PexAssert.AreEqual(values.Count - toRemoveCount, avlTree.Count); IEnumerable enumerator = avlTree.GetInorderEnumerator(); foreach (int i in enumerator) { PexObserve.ValueForViewing <int>("tree nodes", i); } }
public void CompareRemoveTime() { var itemsCount = 10000; var list = new List <int>(); for (int i = 0; i < itemsCount; i++) { list.Add(i); } var startTime = DateTime.Now; list.Remove(5000); var listRemoveTime = DateTime.Now - startTime; var avlTree = new AvlTree <int>(); for (int i = 0; i < itemsCount; i++) { avlTree.Add(i); } startTime = DateTime.Now; avlTree.Remove(5000); var avlRemoveTime = 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; }
public void CompareAddTime() { var itemsCount = 10000; var startTime = DateTime.Now; var list = new List <int>(); for (int i = 0; i < itemsCount; i++) { list.Add(i); } var listAddingTime = DateTime.Now - startTime; startTime = DateTime.Now; var avlTree = new AvlTree <int>(); for (int i = 0; i < itemsCount; i++) { avlTree.Add(i); } var avlAddTree = 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; }
static void Main(string[] args) { var tree = new AvlTree<int>(); //tree.Add(50); //tree.Add(25); //tree.Add(75); //tree.Add(65); //tree.Add(70); //tree.Add(234); //tree.Add(116); //tree.Add(6); //tree.Add(18); //tree.Add(71); //tree.Add(90); //tree.Add(120); //tree.Add(300); int[] nodes = Console.ReadLine().Split().Select(int.Parse).ToArray(); foreach (var node in nodes) { tree.Add(node); } int[] rangeParams = Console.ReadLine().Split().Select(int.Parse).ToArray(); int start = rangeParams[0]; int end = rangeParams[1]; Console.WriteLine(string.Join(" ", tree.Range(start, end))); Console.WriteLine(tree.getRangeCounter); // tree.Add(65); //tree.Add(70); Console.WriteLine(); }
public static AvlTree<CharacterData> Parse(string filePath) { AvlTree<CharacterData> charDictionary = new AvlTree<CharacterData>(); string[] lines = File.ReadAllLines(filePath); for (int i = HeaderSize; i < lines.Length; i += 1) { string firstLine = lines[i]; string[] typesAndValues = firstLine.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); // All the data comes in a certain order, // used to make the parser shorter CharacterData charData = new CharacterData { Id = GetValue(typesAndValues[1]), X = GetValue(typesAndValues[2]), Y = GetValue(typesAndValues[3]), Width = GetValue(typesAndValues[4]), Height = GetValue(typesAndValues[5]), XOffset = GetValue(typesAndValues[6]), YOffset = GetValue(typesAndValues[7]), XAdvance = GetValue(typesAndValues[8]) }; charDictionary.Add(((char)charData.Id).ToString(), charData); } return charDictionary; }
public void Foreach_AddedManyRandomElements_ShouldReturnSortedAscending() { const int NumCount = 10000; var tree = new AvlTree <int>(); var nums = new HashSet <int>(); var random = new Random(); for (int i = 0; i < NumCount; i++) { var num = random.Next(0, NumCount); nums.Add(num); tree.Add(num); } var sortedNumbers = nums.OrderBy(n => n).ToArray(); var expectedSequence = new Queue <int>(sortedNumbers); int count = 0; tree.ForeachDfs((depth, num) => { Assert.AreEqual(expectedSequence.Dequeue(), num); count++; }); Assert.AreEqual(count, tree.Count); }
private void Execute(int[] points) { _testee = new AvlTree <int>(points.Length); var sw = new Stopwatch(); sw.Start(); foreach (var p in points) { _testee.Add(p); } sw.Stop(); Console.WriteLine("Add {0} values to tree was {1}ms", points.Length, sw.ElapsedMilliseconds); Assert.AreEqual(points.Length, _testee.Count); var list = new List <int>(); sw.Reset(); sw.Start(); foreach (var p in points) { var index = list.BinarySearch(p); if (index < 0) { index = ~index; } list.Insert(index, p); } sw.Stop(); Console.WriteLine("Add {0} values to list was {1}ms", points.Length, sw.ElapsedMilliseconds); }
public void GlobalSetup() { var random = new Random(Seed); var set = new HashSet <int>(Count); _data = new int[Count]; _tree = new AvlTree <int>(); _compactTree = new CompactAvlTree <int>(); _list = new List <int>(); _set = new SortedSet <int>(); for (int i = 0; i < Count; i++) { int number; do { number = random.Next(MaxNumber) | 1; } while (!set.Add(number)); _data[i] = number; var num1 = number + 1; _tree.Add(num1); _compactTree.Add(num1); _set.Add(num1); _list.Add(num1); } _list.Sort(); }
public static void Main() { var treeElements = Console.ReadLine().Split().Select(int.Parse); var tree = new AvlTree<int>(); foreach (int element in treeElements) { tree.Add(element); } // Problem 2 - Range var range = Console.ReadLine().Split().Select(int.Parse).ToArray(); var elementsInRange = tree.Range(range[0], range[1]); Console.WriteLine(string.Join(" ", elementsInRange)); // Problem 3 - Indexing //int index; //bool isIndex = int.TryParse(Console.ReadLine(), out index); //while (isIndex) //{ // try // { // Console.WriteLine(tree[index]); // } // catch (IndexOutOfRangeException) // { // Console.WriteLine("Invalid index"); // } // isIndex = int.TryParse(Console.ReadLine(), out index); //} }
static void Index() { var nums = new int[] { -2, 1, 0, 4, 5, 6, 10, 13, 14, 15, 17, 18, 20}; var tree = new AvlTree<int>(); foreach (var num in nums) { tree.Add(num); } string index; Console.WriteLine("Which index? 'q' for end:"); while(true) { index = Console.ReadLine(); if("q" == index) { break; } try { Console.WriteLine(tree[int.Parse(index)]); } catch (IndexOutOfRangeException e) { Console.WriteLine(e.Message); } } }
static void Main() { var elements = Console.ReadLine() .Split(' ') .Select(int.Parse); var avlTree = new AvlTree<int>(); foreach (var element in elements) { avlTree.Add(element); } var rangeTokens = Console.ReadLine() .Split(' ') .Select(int.Parse) .ToList(); var from = rangeTokens[0]; var to = rangeTokens[1]; var range = avlTree.Range(from, to); if (range.Count == 0) { Console.WriteLine("(empty)"); } else { foreach (var element in range) { Console.WriteLine(element); } } }
public void AddSeveralElements_EmptyTree_ShouldIncreaseCount() { var nums = TestUtils.ToIntArrayUnique("1 2 3"); var tree = new AvlTree<int>(); foreach (int num in nums) { tree.Add(num); } Assert.AreEqual(nums.Length, tree.Count); }
public void Add_RepeatingElements_ShouldNotAddDuplicates() { var nums = TestUtils.ToIntArrayUnique("1 1 1"); var tree = new AvlTree<int>(); foreach (int num in nums) { tree.Add(num); } Assert.AreEqual(1, tree.Count); }
/// <summary>Creates a static model from the ids provided.</summary> /// <param name="staticModelId">The id to represent this model as.</param> /// <param name="textures">An array of the texture ids for each sub-mesh of this model.</param> /// <param name="meshes">An array of each mesh id for this model.</param> /// <param name="meshNames">An array of mesh names for this specific instanc3e of a static model.</param> internal StaticModel(string staticModelId, string[] meshNames, string[] meshes, string[] textures) { if (textures.Length != meshes.Length && textures.Length != meshNames.Length) throw new Exception("Attempting to create a static model with non-matching number of components."); _id = staticModelId; _meshes = new AvlTreeLinked<StaticMesh, string>(StaticMesh.CompareTo, StaticMesh.CompareTo); for (int i = 0; i < textures.Length; i++) _meshes.Add(new StaticMesh(meshNames[i], TextureManager.Get(textures[i]), StaticModelManager.GetMesh(meshes[i]).StaticMeshInstance)); _shaderOverride = null; _position = new Vector(0, 0, 0); _scale = new Vector(1, 1, 1); _orientation = Quaternion.FactoryIdentity; }
public void AvlTree_AddDoubleRotateLeft_Test() { Func<int, int, bool> Smaller = (a, b) => { return a < b; }; AvlTree<int> Tree = new AvlTree<int>(Smaller); AvlTree<int>.NodeCheck _3 = AvlTree<int>.NodeCheck.ConvirmValue(3), _1 = AvlTree<int>.NodeCheck.ConvirmValue(1), _2 = AvlTree<int>.NodeCheck.ConvirmValue(2), _4 = AvlTree<int>.NodeCheck.ConvirmValue(4), _5 = AvlTree<int>.NodeCheck.ConvirmValue(5); _3.NextCheck = _1; _1.NextCheck = _2; _2.NextCheck = _4; _4.NextCheck = _5; Tree.Add(1); Tree.Add(4); Tree.Add(3); Tree.Add(5); Tree.Add(2); //Tree.Dump(); Tree.HierarchyCheck(_3); }
static void Range() { Console.WriteLine("Add numbers separated by space"); var nums = Console.ReadLine().Split(' ').Select(Int32.Parse).ToList(); Console.WriteLine("Find range - two numbers separated by space."); var range = Console.ReadLine().Split(' ').Select(Int32.Parse).ToList(); var tree = new AvlTree<int>(); foreach (var num in nums) { tree.Add(num); } tree.Range(range[0], range[1]); Console.WriteLine(); }
static void Main(string[] args) { var tree = new AvlTree<int>(); var random = new Random(); for (int i = 0; i < 20; i++) { var num = random.Next(0, 1000); tree.Add(num); } tree.ForeachDfs((depth, num) => { Console.WriteLine(num); }); }
private static void Main() { var tree = new AvlTree<int>(); tree.Add(11); tree.Add(10); tree.Add(1); tree.Add(15); tree.Add(13); tree.Add(12); var vals = tree.ToArray(); Console.ReadKey(); }
public void AddingMultipleItems_InBalancedWay_ShouldForeachInOrder() { var numbers = TestUtils.ToIntArrayUnique("20 10 30 0 15 25 40"); var tree = new AvlTree<int>(); foreach (int number in numbers) { tree.Add(number); } var sortedNumbers = numbers.OrderBy(n => n).ToArray(); var expectedSequence = new Queue<int>(sortedNumbers); int count = 0; tree.ForeachDfs((depth, num) => { Assert.AreEqual(expectedSequence.Dequeue(), num); count++; }); Assert.AreEqual(count, tree.Count); }
public void AddingMultipleItems_RandomOrder_ShouldForeachInOrder() { var nums = TestUtils.ToIntArrayUnique("1 5 3 20 6 13 40 70 100 200 -50"); var tree = new AvlTree<int>(); foreach (var num in nums) { tree.Add(num); } var sortedNumbers = nums.OrderBy(n => n).ToArray(); var expectedSequence = new Queue<int>(sortedNumbers); int count = 0; tree.ForeachDfs((depth, num) => { Assert.AreEqual(expectedSequence.Dequeue(), num); count++; }); Assert.AreEqual(count, tree.Count); }
public void CompareAddTime() { var itemsCount = 10000; var startTime = DateTime.Now; var list = new List<int>(); for (int i = 0; i < itemsCount; i++) { list.Add(i); } var listAddingTime = DateTime.Now - startTime; startTime = DateTime.Now; var avlTree = new AvlTree<int>(); for (int i = 0; i < itemsCount; i++) { avlTree.Add(i); } var avlAddTree = DateTime.Now - startTime; }
public void TestDetachNodesAtLeftChildAfterDeletingRoot() { var tree = new AvlTree<TestNode> (); int[] keys = { 110, 122, 2, 134, 86, 14, 26, 182 }; foreach (var key in keys) { tree.Add (new TestNode (key)); } tree.Remove (tree.First (t => t.val == 110)); Assert.AreEqual (26, ((TestNode)tree.First (t => t.val == 14).Right).val); }
public void AvlTree_String_ExtendedInsertionRebalance_Test() { Func<string, string, bool> Smaller = (text1, text2) => { return string.Compare(text1, text2, StringComparison.OrdinalIgnoreCase) < 0; }; AvlTree<string> StrTree = new AvlTree<string>(Smaller); StrTree.Add("ORY"); StrTree.Add("JFK"); StrTree.Add("BRU"); StrTree.Add("DUS"); StrTree.Add("ZRH"); StrTree.Add("MEX"); StrTree.Add("ORD"); StrTree.Add("NRT"); StrTree.Add("ARN"); StrTree.Add("GLA"); StrTree.Add("GCM"); AvlTree<string>.NodeCheck _JFK = AvlTree<string>.NodeCheck.ConvirmValue("JFK"), _BRU = AvlTree<string>.NodeCheck.ConvirmValue("BRU"), _ARN = AvlTree<string>.NodeCheck.ConvirmValue("ARN"), _GCM = AvlTree<string>.NodeCheck.ConvirmValue("GCM"), _DUS = AvlTree<string>.NodeCheck.ConvirmValue("DUS"), _GLA = AvlTree<string>.NodeCheck.ConvirmValue("GLA"), _ORY = AvlTree<string>.NodeCheck.ConvirmValue("ORY"), _NRT = AvlTree<string>.NodeCheck.ConvirmValue("NRT"), _MEX = AvlTree<string>.NodeCheck.ConvirmValue("MEX"), _ORD = AvlTree<string>.NodeCheck.ConvirmValue("ORD"), _ZRH = AvlTree<string>.NodeCheck.ConvirmValue("ZRH"); _JFK.NextCheck = _BRU; _BRU.NextCheck = _ARN; _ARN.NextCheck = _GCM; _GCM.NextCheck = _DUS; _DUS.NextCheck = _GLA; _GLA.NextCheck = _ORY; _ORY.NextCheck = _NRT; _NRT.NextCheck = _MEX; _MEX.NextCheck = _ORD; _ORD.NextCheck = _ZRH; StrTree.HierarchyCheck(_JFK); }
public void AvlTree_Balance_Test() { AvlTree<int> Tree = new AvlTree<int>((a, b) => { return a < b; }); Tree.Add(5); Tree.Add(4); Tree.Add(3); Tree.Add(2); Tree.Add(1); Tree.Add(0); Tree.Dump(); AvlTree<int>.NodeCheck RootCheck = new AvlTree<int>.NodeCheck(), Check_Left1 = new AvlTree<int>.NodeCheck(), Check_Right1 = new AvlTree<int>.NodeCheck(), Check_Left1_Left2 = new AvlTree<int>.NodeCheck(), Check_Right1_Left2 = new AvlTree<int>.NodeCheck(), Check_Right1_Right2 = new AvlTree<int>.NodeCheck() ; // This is an explicit structural test RootCheck.Verify = (nodeCheck) => { Console.WriteLine(nodeCheck); Assert.AreEqual(2, nodeCheck.Value); Assert.AreEqual(0, nodeCheck.ParentId); Assert.AreNotEqual(0, nodeCheck.LeftId); Assert.AreNotEqual(0, nodeCheck.RightId); return true; }; RootCheck.NextCheck = Check_Left1; Check_Left1.Verify = (nodeCheck) => { Console.WriteLine(nodeCheck); Assert.AreEqual(1, nodeCheck.Value); Assert.AreEqual(RootCheck.ThisId, nodeCheck.ParentId); Assert.AreEqual(RootCheck.LeftId, nodeCheck.ThisId); Assert.Greater(RootCheck.Value, nodeCheck.Value); Assert.AreNotEqual(0, nodeCheck.LeftId); // should be left node Assert.AreEqual(0, nodeCheck.RightId); // but no right node. return true; }; Check_Left1.NextCheck = Check_Left1_Left2; Check_Left1_Left2.Verify = (nodeCheck) => { Console.WriteLine(nodeCheck); Assert.AreEqual(0, nodeCheck.Value); Assert.AreEqual(0, nodeCheck.LeftId); Assert.AreEqual(0, nodeCheck.RightId); Assert.AreEqual(Check_Left1.ThisId, nodeCheck.ParentId); Assert.Greater(Check_Left1.Value, nodeCheck.Value); return true; }; Check_Left1_Left2.NextCheck = Check_Right1; Check_Right1.Verify = (nodeCheck) => { Console.WriteLine(nodeCheck); Assert.AreEqual(4, nodeCheck.Value); Assert.AreEqual(RootCheck.ThisId, nodeCheck.ParentId); Assert.AreEqual(RootCheck.RightId, nodeCheck.ThisId); Assert.AreNotEqual(0, nodeCheck.LeftId); Assert.AreNotEqual(0, nodeCheck.RightId); Assert.Less(RootCheck.Value, nodeCheck.Value); return true; }; Check_Right1.NextCheck = Check_Right1_Left2; Check_Right1_Left2.Verify = (nodeCheck) => { Console.WriteLine(nodeCheck); Assert.AreEqual(3, nodeCheck.Value); Assert.AreEqual(Check_Right1.ThisId, nodeCheck.ParentId); Assert.AreEqual(Check_Right1.LeftId, nodeCheck.ThisId); Assert.AreEqual(0, nodeCheck.LeftId); Assert.AreEqual(0, nodeCheck.RightId); Assert.Greater(Check_Right1.Value, nodeCheck.Value); return true; }; Check_Right1_Left2.NextCheck = Check_Right1_Right2; Check_Right1_Right2.Verify = (nodeCheck) => { Console.WriteLine(nodeCheck); Assert.AreEqual(5, nodeCheck.Value); Assert.AreEqual(Check_Right1.ThisId, nodeCheck.ParentId); Assert.AreEqual(Check_Right1.RightId, nodeCheck.ThisId); Assert.AreEqual(0, nodeCheck.LeftId); Assert.AreEqual(0, nodeCheck.RightId); Assert.Less(Check_Right1.Value, nodeCheck.Value); return false; // end of tree }; Tree.HierarchyCheck(RootCheck); Console.WriteLine("\r\n: Tree Looks Like:"); Tree.InOrder((num) => { Console.WriteLine("> {0}", num); }); }
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 InsertionRotateRightLeftTest() { AvlTree<int> avlTree = new AvlTree<int>(){6,5,15,7,16}; avlTree.Add(14); Assert.AreEqual(7, avlTree.Root.Value); Assert.AreEqual(6, avlTree.Root.Left.Value); Assert.AreEqual(15, avlTree.Root.Right.Value); Assert.AreEqual(5, avlTree.Root.Left.Left.Value); Assert.AreEqual(14, avlTree.Root.Right.Left.Value); Assert.AreEqual(16, avlTree.Root.Right.Right.Value); }
public void TestRemoveInLeftSubtree() { var tree = new AvlTree<TestNode> (); int[] keys = { 8, 4, 12, 6, 7, 16, 10, 5, 11, 9, 17, 5, 14, 2, 13, 1, 3 }; foreach (var key in keys) { tree.Add (new TestNode (key)); } tree.Remove (tree.First (t => t.val == 16)); Assert.AreEqual( 8, tree.Root.val ); Assert.AreEqual( 12, ((TestNode)tree.Root.Right).val ); Assert.AreEqual( 14, ((TestNode)tree.Root.Right.Right).val ); Assert.AreEqual (13, ((TestNode)tree.First (t => t.val == 14).Left).val); }
public void TestAddCase2() { var tree = new AvlTree<TestNode> (); var t3 = new TestNode (3); var t24 = new TestNode (24); var t26 = new TestNode (26); tree.Add (t3); Assert.AreEqual (1, tree.Count); tree.Remove (t3); tree.Add (new TestNode (37)); tree.Add (new TestNode (70)); tree.Add (new TestNode (12)); Assert.AreEqual (3, tree.Count); tree.Add (new TestNode (90)); tree.Add (new TestNode (25)); tree.Add (new TestNode (99)); tree.Add (new TestNode (91)); tree.Add (t24); tree.Add (new TestNode (28)); tree.Add (t26); // Should do a single left rotation on node with key 12 tree.Remove (t24); Assert.IsTrue (tree.Root.Left == t26, "was:" + tree.Root.Left); }
public void TestTreeRoationAtLeftChildAfterDeletingRoot() { var tree = new AvlTree<TestNode> (); int[] keys = { 86, 110, 122, 2, 134, 26, 14, 182 }; int[] expectedKeys = { 2, 14, 26, 86, 122, 134, 182 }; foreach (var key in keys) { tree.Add (new TestNode (key)); } tree.Remove (tree.First (t => t.val == 110)); var node = tree.Root.AvlGetOuterLeft (); foreach (var expected in expectedKeys) { Assert.AreEqual (expected, node.val); node = node.AvlGetNextNode (); } }
public void ShouldBalanceTreeWhenItIsLeftLeftOverweightInTheLeftSubtree() { var avlTree = new AvlTree<int>(new int[] { 25, 40, 17, 15, 22 }); avlTree.Add(14); Assert.AreEqual(17, avlTree.Root.Value); Assert.AreEqual(15, avlTree.Root.LeftChild.Value); Assert.AreEqual(14, avlTree.Root.LeftChild.LeftChild.Value); Assert.AreEqual(25, avlTree.Root.RightChild.Value); Assert.AreEqual(22, avlTree.Root.RightChild.LeftChild.Value); Assert.AreEqual(40, avlTree.Root.RightChild.RightChild.Value); }
public void TestRemoveInRightSubtree() { var tree = new AvlTree<TestNode> (); int[] keys = { 8, 4, 13, 6, 15, 7, 10, 5, 14, 2, 11, 3, 9, 1 }; foreach (var key in keys) { tree.Add (new TestNode (key)); } tree.Remove (tree.First (t => t.val == 13)); Assert.AreEqual (11, ((TestNode)tree.First (t => t.val == 8).Right).val); }
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 void InsertionAndDeletionTest() { AvlTree<uint> avlTree = new AvlTree<uint>(); avlTree.Add(28); avlTree.Add(22); avlTree.Add(3); avlTree.Add(7); avlTree.Add(14); avlTree.Add(9); avlTree.Add(19); avlTree.Add(55); avlTree.Add(23); avlTree.Add(4); avlTree.Add(1); avlTree.Add(6); avlTree.Add(15); Assert.AreEqual(avlTree.Root.Value, 14); Assert.AreEqual(avlTree.Root.Left.Value, 4); Assert.AreEqual(avlTree.Root.Right.Value, 22); avlTree.Remove(4); avlTree.Remove(3); avlTree.Remove(1); avlTree.Remove(9); avlTree.Remove(23); avlTree.Remove(14); Assert.AreEqual(7, avlTree.Count); Assert.AreEqual(22, avlTree.Root.Value); Assert.AreEqual(7, avlTree.Root.Left.Value); Assert.AreEqual(28, avlTree.Root.Right.Value); Assert.AreEqual(55, avlTree.Root.Right.Right.Value); Assert.AreEqual(6, avlTree.Root.Left.Left.Value); Assert.AreEqual(19, avlTree.Root.Left.Right.Value); Assert.AreEqual(15, avlTree.Root.Left.Right.Left.Value); }