//Ans // 5 // 3 7 // 2 4 6 8 //Find ele at length/2 (odd) and insert , call recursively left arry and right arr. // if length is 1 - insert, if lngth public void Run() { int[] inputArr = new[] { 2, 3, 4, 6, 7, 8 }; var newTree = new BinarySearchTree<int>(); InsertToTree(inputArr, newTree); }
public void CanEnumerateDepthFirstSearch() { var tree = new BinarySearchTree<int, int>(new[] {3, 2, 1, 2, 4, 3}.AsKeyValueList()); var expected = new[] {3, 2, 1, 2, 4, 3}; CollectionAssert.AreEqual(expected, tree.DepthFirstSearchEnumerator().Select(_ => _.Value).ToList()); }
public bool Check(BinarySearchTree<int>.Node<int> root) { if (root == null) return true; return Check(root.Left, int.MinValue, root.Data) && Check(root.Right, root.Data, int.MaxValue); }
//public static void Main(string[] args) //{ //DoubleLinkedList<int> list = new DoubleLinkedList<int>(); //SingleLinkedList<int> list = new SingleLinkedList<int>(); //int index = 5; //Console.WriteLine("The ADD Method and toString"); //Add Method and toString //list.Add(12); //list.Add(20); //list.Add(1); //list.Add(0); //list.Add(121); //list.Add(420); //list.Add(78); //list.Add(90); //list.Add(34); //list.Add(4); //Console.WriteLine(list.ToString()); //Console.WriteLine("\nThe COUNT Method"); //Console.WriteLine("The the count of this list is: " + list.Count); //Console.WriteLine("\nThe INSERT Method"); //Console.WriteLine("I am inserting the number 22 at index: " + index); //list.Insert(22, index); //Console.WriteLine("New List: " + list.ToString()); //Console.WriteLine("\nThe COUNT Method"); //Console.WriteLine("The the count of this list is: " + list.Count); //Console.WriteLine("\nThe Get Method"); //Console.WriteLine("What is at index " + index + ": " + list.Get(index)); //Console.WriteLine("\nThe REMOVEAT Method"); //Console.WriteLine("What is at index " + (list.Count - 1) + ": " + list.Get((list.Count - 1))); //Console.WriteLine("I am removing the element at index " + (list.Count - 1) + ": " + list.RemoveAt((list.Count - 1))); //Console.WriteLine("New List: " + list.ToString()); //Console.WriteLine("\nThe COUNT Method"); //Console.WriteLine("The the count of this list is: " + list.Count); //Console.WriteLine("\nThe INSERT Method"); //Console.WriteLine("I am inserting the number 15 at index: " + ); //list.Insert(15,(list.Count - 1)); //Console.WriteLine("New List: " + list.ToString()); //Console.WriteLine("\nThe COUNT Method"); //Console.WriteLine("The the count of this list is: " + list.Count); //Console.WriteLine("\nThe SEARCH Method"); //Console.WriteLine("Searching for 1: " + list.Search(1)); //Console.WriteLine("\nThe REMOVE Method"); //Console.WriteLine(list.Remove()); //Console.WriteLine("New List: " + list.ToString()); //Console.WriteLine("\nThe COUNT Method"); //Console.WriteLine("The the count of this list is: " + list.Count); //Console.WriteLine("\nThe REMOVELAST Method"); //Console.WriteLine(list.RemoveLast()); //Console.WriteLine("New List: " + list.ToString()); //Console.WriteLine("\nThe COUNT Method"); //Console.WriteLine("The the count of this list is: " + list.Count); //Console.WriteLine("\nThe CLEAR Method"); //list.Clear(); //Console.WriteLine("New List: " + list.ToString()); // Console.WriteLine("\nThe REMOVEAT Method"); // Console.WriteLine("What is at index " + index + ": " + list.Get(index)); // //Console.WriteLine("I am removing the element at index " + index + ": " + list.RemoveAt(index)); // Console.WriteLine("New List: " + list.ToString()); // Console.WriteLine("\nThe COUNT Method"); // Console.WriteLine("The the count of this list is: " + list.Count); //} public static void Main(string[] args) { BinarySearchTree<int> bst = new BinarySearchTree<int>(); bst.Add(24); bst.Add(10); bst.Add(1337); //bst.Add(50); //bst.Add(1472); //bst.Add(72); //bst.Add(1360); //bst.Add(1345); //bst.Add(54); //bst.Add(20); //bst.Add(9); //bst.Add(19); //bst.Add(14); //bst.Add(67); //bst.Add(35); //bst.Add(80); //bst.Add(65); //bst.Add(24); //bst.Add(5); Console.WriteLine("Count:" + bst.Count); //Console.WriteLine("\ncontains 24: " + bst.Contains(24)); //Console.WriteLine("\ncontains 0: " + bst.Contains(0)); //Console.WriteLine("\nInorder:" + bst.Inorder()); //Console.WriteLine("\nRemove: I'm removing 17 : " + bst.Remove(17)); Console.WriteLine("\nInorder:" + bst.Inorder()); Console.WriteLine("\nRemove: I'm removing 24 : " + bst.Remove(24)); //bst.Clear(); Console.WriteLine("\nCount:" + bst.Count); Console.WriteLine("\nInorder:" + bst.Inorder()); //Console.WriteLine("\nPostorder:" + bst.Postorder()); //Console.WriteLine("\nPreorder:" + bst.Preorder()); //Console.WriteLine(); //Console.WriteLine("\nPreorder:" + bst.Preorder()); //Console.WriteLine(); //Console.WriteLine("\nPostorder:" + bst.Postorder()); foreach (var item in bst.ToArray()) { Console.WriteLine(item); } Console.ReadLine(); }
static void Main() { var sb = new StringBuilder(); var tree = new BinarySearchTree<int>(15); for (int i = 0; i < 30; i++) { tree.Add(i); } var clonedNode = (TreeNode<int>)tree.Root.Clone(); sb.AppendLine(tree.ToString()) .AppendLine("Tree root: " + tree.Root.ToString()) .AppendLine("Tree contains 7? " + tree.Contains(7).ToString()) .AppendLine("Cloned root: " + clonedNode.ToString()) .AppendLine("Cloned Equals root? " + (clonedNode.Equals(tree.Root)).ToString()) .AppendLine("Cloned == root? " + (clonedNode == tree.Root).ToString()) .AppendLine("Cloned != root? " + (clonedNode != tree.Root).ToString()) .AppendLine("12 deleted. New tree:"); Console.Write(sb.ToString()); tree.Delete(12); Console.WriteLine(tree.ToString()); }
public void BinarySearchTree_InitWithValues_IsInOrder() { testTree = new BinarySearchTree<int>( new []{ 50, 60, 40 }); Assert.AreEqual(50, testTree.Root.Value); Assert.AreEqual(40, testTree.Root.LeftChild.Value); Assert.AreEqual(60, testTree.Root.RightChild.Value); }
public void NonIComparable() { var tree = new BinarySearchTree<NonComparableTClass, string> { {new NonComparableTClass(4), "4"}, {new NonComparableTClass(6), "6"}, {new NonComparableTClass(2), "2"}, {new NonComparableTClass(5), "5"}, {new NonComparableTClass(19), "19"}, {new NonComparableTClass(1), "1"} }; var newTree = SerializeUtil.BinarySerializeDeserialize(tree); Assert.AreNotSame(tree, newTree); Assert.AreEqual(tree.Count, newTree.Count); var treeEnumerator = tree.GetEnumerator(); var newTreeEnumerator = newTree.GetEnumerator(); while (treeEnumerator.MoveNext()) { Assert.IsTrue(newTreeEnumerator.MoveNext()); Assert.AreEqual(treeEnumerator.Current.Key.Number, newTreeEnumerator.Current.Key.Number); Assert.AreEqual(treeEnumerator.Current.Value, newTreeEnumerator.Current.Value); Assert.IsTrue(newTree.ContainsKey(treeEnumerator.Current.Key)); Assert.AreEqual(newTree[treeEnumerator.Current.Key], treeEnumerator.Current.Value); } Assert.IsFalse(newTreeEnumerator.MoveNext()); }
public void KeyValuePair() { var tree = new BinarySearchTree<int, string> { {4, "4"}, {6, "6"}, {2, "2"}, {5, "5"}, {19, "19"}, {1, "1"} }; Assert.AreEqual(tree.Count, 6); Assert.IsTrue(tree.ContainsKey(4)); Assert.IsTrue(tree.ContainsKey(6)); Assert.IsTrue(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsTrue(tree.ContainsKey(19)); Assert.IsTrue(tree.ContainsKey(1)); Assert.IsFalse(tree.Remove(new KeyValuePair<int, string>(20, "20"))); Assert.IsTrue(tree.Remove(new KeyValuePair<int, string>(4, "4"))); Assert.AreEqual(tree.Count, 5); Assert.IsFalse(tree.ContainsKey(4)); Assert.IsTrue(tree.ContainsKey(6)); Assert.IsTrue(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsTrue(tree.ContainsKey(19)); Assert.IsTrue(tree.ContainsKey(1)); }
public void CanFindElementInOneElementTree() { var tree = new BinarySearchTree<int, int>(); tree.Insert(new KeyValue<int, int>(1, 2)); Assert.AreEqual(2, tree[1]); }
public void CanFindMinimumInOneElementTree() { var tree = new BinarySearchTree<int, int>(); tree.Insert(1.AsKeyValue()); Assert.AreEqual(1, tree.Minimum); }
public void Simple() { var tree = new BinarySearchTree<int, string>(); var dictionary = new Dictionary<int, string>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 50; i++) { var gen = rand.Next(2000); while (dictionary.ContainsKey(gen)) { gen = rand.Next(2000); } dictionary.Add(gen, null); tree.Add(gen, gen.ToString()); Assert.AreEqual(tree.Count, i + 1); Assert.IsTrue(tree.ContainsKey(gen)); } using (var enumerator = dictionary.GetEnumerator()) { while (enumerator.MoveNext()) { Assert.IsTrue(tree.Remove(enumerator.Current)); } } }
public void CopyContructorTest() { List<string> collection = new List<string> { "Granville", "Barnett", "Luca", "Del", "Tongo" }; BinarySearchTree<string> actual = new BinarySearchTree<string>(collection); Assert.AreEqual(5, actual.Count); }
public void ContainsItemNotPresentTest() { BinarySearchTree<int> bst = new BinarySearchTree<int> {12, 5, 3, 8, 42}; Assert.IsFalse(bst.Contains(99)); Assert.IsFalse(bst.Contains(1)); }
static void Main() { BinarySearchTree<int> tree = new BinarySearchTree<int>(); tree.AddElement(13); tree.AddElement(17); tree.AddElement(101); tree.AddElement(44); tree.AddElement(9); tree.AddElement(11); BinarySearchTree<int> tree2 = (BinarySearchTree<int>)tree.Clone(); //tree2.AddElement(45); //tree2.AddElement(99); Console.WriteLine("Tree: " + tree.ToString()); Console.WriteLine("Tree2: " + tree2.ToString()); Console.WriteLine("Tree equals Tree2: " + tree.Equals(tree2)); Console.WriteLine("Tree == Tree2: " + (tree == tree2)); Console.WriteLine("Tree != Tree2: " + (tree != tree2)); Console.Write("Traverse with foreach: "); foreach (TreeNode<int> item in tree) Console.Write(item.Value + " "); Console.WriteLine(); Console.WriteLine("Tree hash: {0}", tree.GetHashCode()); Console.WriteLine("Tree2 hash: {0}", tree2.GetHashCode()); }
public void ClearTest(string[] elements) { BinarySearchTree<string> bst = new BinarySearchTree<string>(elements); bst.Clear(); PexAssert.IsNull(bst.Root); PexAssert.AreEqual(0, bst.Count); }
public void Simple() { var tree = new BinarySearchTree<int, string>(); var dictionary = new Dictionary<int, string>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 50; i++) { var gen = rand.Next(2000); while (dictionary.ContainsKey(gen)) { gen = rand.Next(2000); } dictionary.Add(gen, null); tree.Add(gen, gen.ToString()); Assert.IsTrue(tree.ContainsKey(gen)); Assert.AreEqual(tree[gen], gen.ToString()); } }
public void BinaryTreeMustSortTheSameAsSortedDictionary() { // Arrange var asm = Assembly.GetExecutingAssembly(); var importer = new Importer(asm.GetManifestResourceStream("ClientImport.Tests.records.txt"), ','); var dictionary = new SortedDictionary<string, IPerson>(); var tree = new BinarySearchTree<string, IPerson>(); //Act importer.Data .ToList() .ForEach(record => { var person = new Person { FirstName = record.FirstName, Surname = record.Surname, Age = Convert.ToInt16(record.Age) }; var key = PersonRepository.BuildKey(person, SortKey.SurnameFirstNameAge); if (tree.Find(key) == null) tree.Add(key, person); } ); tree .ToList() .Shuffle() //Shuffle result from binary tree, to test sorting .ForEach(r => dictionary.Add(PersonRepository.BuildKey(r.KeyValue.Value, SortKey.SurnameFirstNameAge), r.KeyValue.Value)); var expected = dictionary.Select(r => r.Value).ToList(); var actual = tree.Select(n => n.KeyValue.Value).ToList(); // Assert CollectionAssert.AreEqual(expected, actual); }
public void ShouldCreateBinarySearchTreeWithGivenRoot() { var rootNode = new BinaryTreeNode<int>(null); var binarySearchTree = new BinarySearchTree<int>(rootNode); Assert.AreEqual(rootNode, binarySearchTree.Root); }
static void Main(string[] args) { BinarySearchTree<string> tree = new BinarySearchTree<string>() { new TreeNode<string>("first") }; }
public void DeleteTest() { BinarySearchTree target = new BinarySearchTree(); // TODO: Initialize to an appropriate value int key = 0; BinarySearchTree.Node delNode = target.Search(key); target.Delete(delNode); Assert.Inconclusive("Verify the correctness of this test method."); }
public void InsertTest() { var tree = new BinarySearchTree<string>(); tree.Insert("new value"); Assert.AreEqual(1, tree.Height); Assert.IsNotNull(tree.Head); }
public void TestBinarySearchTreeEquals3() { BinarySearchTree<int> tree1 = new BinarySearchTree<int>(1, 9, 7); BinarySearchTree<int> tree2 = tree1; Assert.AreEqual(true, tree1.Equals(tree2)); }
public void TestBinarySearchTreeOperatorEquals() { BinarySearchTree<int> tree1 = new BinarySearchTree<int>(1, 9, 7); BinarySearchTree<int> tree2 = tree1; Assert.AreEqual(true, tree1 == tree2); }
public void ContainsTest() { BinarySearchTree<int> bst = new BinarySearchTree<int> {12, 5, 3, 8, 42}; Assert.IsTrue(bst.Contains(12)); Assert.IsTrue(bst.Contains(3)); Assert.IsTrue(bst.Contains(42)); }
public void BinarySearchTreeTests_GetHeight() { IBinarySearchTree<int, string> tree = new BinarySearchTree<int, string>(); int height = tree.GetHeight(); Assert.AreEqual(0, height); }
public void ShouldCreateBinarySearchTreeWithGivenRootAndUpdateTheCounter() { var rootNode = new BinaryTreeNode<int>(null); var binarySearchTree = new BinarySearchTree<int>(rootNode); Assert.AreEqual(1, binarySearchTree.Count); }
public void CopyTo_InOrder_Test() { var bst = new BinarySearchTree<int>() { 90, 50, 150, 20, 75, 95, 175, 5, 25, 66, 80, 92, 111, 166, 200 }; int[] expected = new int[] { 5, 20, 25, 50, 66, 75, 80, 90, 92, 95, 111, 150, 166, 175, 200 }; int[] actual = new int[bst.Count]; bst.CopyTo(actual, 0, TraversalMethod.Inorder); CollectionAssert.AreEqual(expected, actual, "Inorder bst traversal did not sort correctly"); }
public void ContainsTest([PexAssumeUnderTest]List<int> elements, int newElement) { PexAssume.IsFalse(elements.Contains(newElement)); BinarySearchTree<int> bst = new BinarySearchTree<int>(elements); foreach(int elem in elements) PexAssert.IsTrue(bst.Contains(elem)); PexAssert.IsFalse(bst.Contains(newElement)); }
public void Init() { tree = new BinarySearchTree<int>(5); tree.LeftChild = new BinarySearchTree<int>(3); tree.RightChild = new BinarySearchTree<int>(8); tree.LeftChild.LeftChild = new BinarySearchTree<int>(1); tree.RightChild.RightChild = new BinarySearchTree<int>(9); AssertIsValid(tree); }
public void ClearTest() { BinarySearchTree<int> bst = new BinarySearchTree<int> {10, 5, 15}; bst.Clear(); Assert.IsNull(bst.Root); Assert.AreEqual(0, bst.Count); }
public static void Insert(this BinarySearchTree <int> tree, int val) { }
public void Data_is_retained() { var tree = new BinarySearchTree(4); Assert.That(tree.Value, Is.EqualTo(4)); }
public void AddingAfterRemovingAllElements() { var tree = new BinarySearchTree <int>(); int elementsCount = 10000; //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 void ExceptionSetInvalidKey() { var tree = new BinarySearchTree <int, string>(); tree[4] = "testString"; }
public BinarySearchTreePreOrderEnumerator(BinarySearchTree <T> tree) : base(tree) { }
private void CreateSUT() { SUT = new BinarySearchTree <int>(); }
private void CreateSUT(BinaryTreeNode <int> root) { SUT = new BinarySearchTree <int>(); SUT.Root = root; }
public void InOrderStringTest() { BinarySearchTree <string> tree = new BinarySearchTree <string>(new string[] { "1", "2", "3", "4" }); CollectionAssert.AreEqual(new string[] { "1", "2", "3", "4" }, tree.InOrder()); }
public void TestFindMin_EmptyException() { BinarySearchTree <int> bst = new BinarySearchTree <int>(); int min = bst.Min; }
public void Simple2() { var tree = new BinarySearchTree <int, string> { { 4, "4" }, { 6, "6" }, { 2, "2" }, { 5, "5" }, { 19, "19" }, { 1, "1" } }; Assert.AreEqual(tree.Count, 6); Assert.IsTrue(tree.ContainsKey(4)); Assert.IsTrue(tree.ContainsKey(6)); Assert.IsTrue(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsTrue(tree.ContainsKey(19)); Assert.IsTrue(tree.ContainsKey(1)); Assert.IsFalse(tree.Remove(20)); Assert.IsTrue(tree.Remove(4)); Assert.AreEqual(tree.Count, 5); Assert.IsFalse(tree.ContainsKey(4)); Assert.IsTrue(tree.ContainsKey(6)); Assert.IsTrue(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsTrue(tree.ContainsKey(19)); Assert.IsTrue(tree.ContainsKey(1)); Assert.IsTrue(tree.Remove(2)); Assert.AreEqual(tree.Count, 4); Assert.IsFalse(tree.ContainsKey(4)); Assert.IsTrue(tree.ContainsKey(6)); Assert.IsFalse(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsTrue(tree.ContainsKey(19)); Assert.IsTrue(tree.ContainsKey(1)); Assert.IsTrue(tree.Remove(19)); Assert.AreEqual(tree.Count, 3); Assert.IsFalse(tree.ContainsKey(4)); Assert.IsTrue(tree.ContainsKey(6)); Assert.IsFalse(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsFalse(tree.ContainsKey(19)); Assert.IsTrue(tree.ContainsKey(1)); Assert.IsFalse(tree.Remove(20)); Assert.IsTrue(tree.Remove(1)); Assert.AreEqual(tree.Count, 2); Assert.IsFalse(tree.ContainsKey(4)); Assert.IsTrue(tree.ContainsKey(6)); Assert.IsFalse(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsFalse(tree.ContainsKey(19)); Assert.IsFalse(tree.ContainsKey(1)); Assert.IsTrue(tree.Remove(6)); Assert.AreEqual(tree.Count, 1); Assert.IsFalse(tree.ContainsKey(4)); Assert.IsFalse(tree.ContainsKey(6)); Assert.IsFalse(tree.ContainsKey(2)); Assert.IsTrue(tree.ContainsKey(5)); Assert.IsFalse(tree.ContainsKey(19)); Assert.IsFalse(tree.ContainsKey(1)); Assert.IsTrue(tree.Remove(5)); Assert.AreEqual(tree.Count, 0); Assert.IsFalse(tree.ContainsKey(4)); Assert.IsFalse(tree.ContainsKey(6)); Assert.IsFalse(tree.ContainsKey(2)); Assert.IsFalse(tree.ContainsKey(5)); Assert.IsFalse(tree.ContainsKey(19)); Assert.IsFalse(tree.ContainsKey(1)); Assert.IsFalse(tree.Remove(1)); }
public void TestFindMax() { BinarySearchTree <int> bst = GetRandomTree(); Assert.That(bst.Max, Is.EqualTo(GetRandomArray().Max())); }
public static void Main() { var list = new List <int>() { 1, 2, 3 }; var bst = new BinarySearchTree <int>(); bst.Add(5); bst.Add(3); bst.Add(10); bst.Add(4); bst.Add(-4); foreach (var node in bst) { Console.WriteLine(node); } Console.WriteLine($"BST Contains -4: {bst.Contains(-4)}"); Console.WriteLine($"BST Contains -40: {bst.Contains(-40)}"); Console.WriteLine(bst.Count); bst.Remove(-4); Console.WriteLine(bst.Count); Console.WriteLine("---------------"); foreach (var node in bst) { Console.WriteLine(node); } var a = bst[3]; Console.WriteLine("-----"); bst.Add(-100); for (int i = 0; i < bst.Count; i++) { Console.WriteLine($"Index={i}: {bst[i]}"); } bst.Clear(); bst.Add(20); bst.Add(40); bst.Add(10); bst.Add(5); bst.Add(15); bst.Add(30); bst.Add(50); bst.Add(35); foreach (var node in bst) { Console.WriteLine(node); } Console.WriteLine(bst[6]); bst.Remove(40); Console.WriteLine("--------"); foreach (var node in bst) { Console.WriteLine(node); } Console.WriteLine("In ragne [10..30]:"); var range = bst.Range(10, 30); foreach (var item in range) { Console.WriteLine(item); } }
public void BinarySearchTree_FindMaxValue_With_Empty_Tree() { BinarySearchTree tree = new BinarySearchTree(); Assert.AreEqual(null, tree.FindMaxValue(tree.Root)); }
public void BinarySearchTreeTurnOperationsTest() { var rand = new Random(); var tree = new BinarySearchTree <int, int>(); var list = new List <int>(); void Insert(int value) { var count = tree.Count; tree.Insert(new ComparableElement <int, int> { Key = value, Value = value }); list.Add(value); } void ValidateBinarySearchTree() { var orderedPlainList = list.OrderBy(x => x).ToList(); var orderedTreeList = tree.OrderedList.ToList(); Assert.AreEqual(list.Count, orderedTreeList.Count, "Invalid tree count"); Assert.AreEqual(orderedPlainList.Last(), tree.Max.Key, "Invalid tree max"); Assert.AreEqual(orderedPlainList.First(), tree.Min.Key, "Invalid tree min"); for (var i = 0; i < orderedTreeList.Count; ++i) { Assert.AreEqual(orderedPlainList[i], orderedTreeList[i].Key, $"Invalid tree nodes order in index:{i}, value:{orderedTreeList[i].Key}"); } } Insert(12); Insert(20); Insert(3); Insert(7); Insert(4); Insert(9); Insert(11); Insert(10); Insert(18); Insert(8); Insert(14); Insert(13); Insert(19); Assert.ThrowsException <ArgumentException>(() => tree.TurnLeft(11), "impossible to do left turn"); tree.TurnLeft(3); ValidateBinarySearchTree(); Assert.ThrowsException <ArgumentException>(() => tree.TurnRight(3), "impossible to do right turn"); tree.TurnRight(20); ValidateBinarySearchTree(); Insert(26); Insert(30); Insert(23); Insert(24); Insert(21); Assert.ThrowsException <ArgumentException>(() => tree.TurnBigLeft(3), "impossible to do big left turn"); tree.TurnBigLeft(20); ValidateBinarySearchTree(); Insert(16); Insert(17); Insert(15); Assert.ThrowsException <ArgumentException>(() => tree.TurnBigRight(3), "impossible to do big right turn"); tree.TurnBigRight(18); ValidateBinarySearchTree(); }
public void CanSuccessfullyInstantiateAnEmptyTree() { BinarySearchTree <char> binarySearchTree = new BinarySearchTree <char>(); Assert.NotNull(binarySearchTree); }
public void TestInsert_DuplicateItemException() { BinarySearchTree <int> bst = GetRandomTree(); bst.Insert(GetRandomArray().First()); }
public void ExceptionGetInvalidKey() { var tree = new BinarySearchTree <int, string>(); var s = tree[4]; }
public int MaxValue_Int32UserComparer() { var tree = new BinarySearchTree <int>(new int[] { 7, 5, 4, 6, 2, 1, 99, 8, 10 }, new Int32Comparer()); return(tree.MaxValue()); }
public void Iterating_over_complex_element() { var elements = new BinarySearchTree(new[] { 4, 2, 1, 3, 6, 7, 5 }).AsEnumerable(); Assert.That(elements, Is.EqualTo(new[] { 1, 2, 3, 4, 5, 6, 7 })); }
static void Main(string[] args) { /*Console.WriteLine("\nSTACK:"); * Stack<int> myStack = new Stack<int>(); * myStack.Push(1); * myStack.Push(2); * Console.WriteLine($"Peeked: {myStack.Peek()}"); * Console.WriteLine($"Popped: {myStack.Pop()}"); * Console.WriteLine($"Popped: {myStack.Pop()}"); * * Console.WriteLine("\nQUEUE:"); * //CircularQueue<int> myQueue = new CircularQueue<int>(3); * Queue<int> myQueue = new Queue<int>(); * myQueue.Append(3); * myQueue.Append(4); * myQueue.Append(5); * Console.WriteLine($"Peeked: {myQueue.Peek()}"); * Console.WriteLine($"Removed: {myQueue.Remove()}"); * Console.WriteLine($"Removed: {myQueue.Remove()}"); * * Console.WriteLine("\nPOSTFIX:"); * string equation = "4 2 + 3 5 1 - * +"; * Console.WriteLine($"[{equation}] is {Postfix.Evaluate(equation)}"); * Console.WriteLine($"[{equation}] is {Postfix.GetInfix(equation)}"); * * Console.WriteLine("\nLINKED LIST:"); * LinkedList<int> myLinkedList = new LinkedList<int> { 3, 1, 4, 1, 5 }; * * Console.WriteLine(myLinkedList.Count); * int[] array = new int[myLinkedList.Count]; * myLinkedList.CopyTo(array, 0); * foreach (var item in array) Console.WriteLine(item); * * myLinkedList.Remove(4); * myLinkedList.RemoveAt(0); * myLinkedList.RemoveAt(0); * myLinkedList.Insert(1, 200); * myLinkedList.Insert(2, 100); * foreach (var item in array) Console.WriteLine(item); * * Console.WriteLine(myLinkedList.Contains(100)); * Console.WriteLine(myLinkedList.IndexOf(100)); * foreach (var element in myLinkedList) Console.WriteLine(element); * * myLinkedList.Clear(); * Console.WriteLine(myLinkedList.Count);*/ Console.WriteLine("\nBINARY SEARCH TREE:"); BinarySearchTree myBST = new BinarySearchTree(); myBST.Insert(3); myBST.Insert(-4); myBST.Insert(5); myBST.Inorder(); myBST.Postorder(); Console.WriteLine(myBST.Contains(-4)); Console.WriteLine(myBST.Contains(20)); myBST.Remove(-4); Console.WriteLine(myBST.Contains(-4)); myBST.Inorder(); myBST.Insert(0); myBST.Insert(4); myBST.BreadthFirst(); }
public void Iterating_over_larger_element() { var elements = new BinarySearchTree(new[] { 4, 5 }).AsEnumerable(); Assert.That(elements, Is.EqualTo(new[] { 4, 5 })); }
public void BinarySearchTreeCrudOperationsTest() { var rand = new Random(); var tree = new BinarySearchTree <int, int>(); var list = new List <int>(); Assert.IsTrue(tree.IsEmpty, "tree is not empty"); Insert(12); Assert.ThrowsException <ArgumentException>(() => tree.Insert(new ComparableElement <int, int> { Key = 12, Value = 12 })); Insert(20); Assert.IsNull(tree.Find(34), "34 not exists in tree"); Insert(3); Insert(7); Insert(4); Insert(9); Insert(11); Assert.IsNotNull(tree.Find(7), "7 exists in tree"); Insert(10); Insert(18); Insert(8); Insert(17); Insert(15); Insert(19); Assert.AreEqual(11, tree.FindPredecessor(12).Key, "invalid predecessor for 12"); Assert.AreEqual(15, tree.FindSuccessor(12).Key, "invalid successor for 12"); Assert.AreEqual(list.Count, tree.Count, "invalid tree count"); Assert.AreEqual(list.Count, tree.OrderedList.Count(), "invalid orderedlist count"); Assert.AreEqual(list.Max(), tree.Max.Key, "invalid tree max"); Assert.AreEqual(list.Min(), tree.Min.Key, "invalid tree min"); Assert.AreEqual(6, tree.Height, "tree height"); Assert.AreEqual(5, tree.LeftHeight, "left subtree height"); Assert.AreEqual(4, tree.RightHeight, "right subtree height"); //delete Assert.ThrowsException <ArgumentException>(() => tree.Delete(34)); Delete(4); Delete(20); Delete(9); //delete void Insert(int value) { var count = tree.Count; tree.Insert(new ComparableElement <int, int> { Key = value, Value = value }); list.Add(value); Assert.AreEqual(count + 1, tree.Count, "Invalid tree count when insert"); ValidateBinarySearchTree(); } void Delete(int value) { var count = tree.Count; tree.Delete(value); list.Remove(value); Assert.AreEqual(count - 1, tree.Count, "Invalid tree count when insert"); ValidateBinarySearchTree(); } void ValidateBinarySearchTree() { var orderedPlainList = list.OrderBy(x => x).ToList(); var orderedTreeList = tree.OrderedList.ToList(); Assert.AreEqual(list.Count, orderedTreeList.Count, "Invalid tree count"); Assert.AreEqual(orderedPlainList.Last(), tree.Max.Key, "Invalid tree max"); Assert.AreEqual(orderedPlainList.First(), tree.Min.Key, "Invalid tree min"); for (var i = 0; i < orderedTreeList.Count; ++i) { Assert.AreEqual(orderedPlainList[i], orderedTreeList[i].Key, $"Invalid tree nodes order in index:{i}, value:{orderedTreeList[i].Key}"); } } }
public string MaxValue_StringUserComparer() { var tree = new BinarySearchTree <string>(new string[] { "aa", "abcd", "wwwwww", "xzy" }, new StringComparer()); return(tree.MaxValue()); }
public void Contains_should_return_correct_value(bool expected, int value) { var result = BinarySearchTree.Contains(n2, value); Assert.Equal(expected, result); }
public void TestRemoveMin_ElementNotFoundException() { BinarySearchTree <int> emptyTree = new BinarySearchTree <int>(); emptyTree.RemoveMin(); }
private void update_source_list() { BinarySearchTree <string> binarySearchTree = new BinarySearchTree <string>(); foreach (EncyclopediaEntry entry in Session.Project.Encyclopedia.Entries) { if (entry.Category == null || !(entry.Category != "")) { continue; } binarySearchTree.Add(entry.Category); } List <string> sortedList = binarySearchTree.SortedList; sortedList.Insert(0, "Background Items"); sortedList.Add("Miscellaneous"); sortedList.Add("Player Options"); this.SourceList.Groups.Clear(); foreach (string str in sortedList) { this.SourceList.Groups.Add(str, str); } this.SourceList.ShowGroups = true; this.SourceList.Items.Clear(); foreach (Background background in Session.Project.Backgrounds) { if (this.fItems.Contains(background) || background.Details == "") { continue; } ListViewItem item = this.SourceList.Items.Add(background.Title); item.Tag = background; item.Group = this.SourceList.Groups["Background Items"]; } foreach (EncyclopediaEntry encyclopediaEntry in Session.Project.Encyclopedia.Entries) { if (this.fItems.Contains(encyclopediaEntry) || encyclopediaEntry.Details == "") { continue; } ListViewItem listViewItem = this.SourceList.Items.Add(encyclopediaEntry.Name); listViewItem.Tag = encyclopediaEntry; if (encyclopediaEntry.Category == null || !(encyclopediaEntry.Category != "")) { listViewItem.Group = this.SourceList.Groups["Miscellaneous"]; } else { listViewItem.Group = this.SourceList.Groups[encyclopediaEntry.Category]; } } foreach (IPlayerOption playerOption in Session.Project.PlayerOptions) { if (this.fItems.Contains(playerOption)) { continue; } ListViewItem item1 = this.SourceList.Items.Add(playerOption.Name); item1.Tag = playerOption; item1.Group = this.SourceList.Groups["Player Options"]; } if (this.SourceList.Items.Count == 0) { this.SourceList.ShowGroups = false; ListViewItem grayText = this.SourceList.Items.Add("(no items)"); grayText.ForeColor = SystemColors.GrayText; } }
public OrderedSet() { this.bst = new BinarySearchTree <T>(); }
public void TestFindMax_EmptyException() { BinarySearchTree <int> bst = new BinarySearchTree <int>(); int max = bst.Max; }
public BstTester() { Output = $"BST Tester: {CommandText}"; _tree = new BinarySearchTree <int>(); }
public void BinarySearchTree_String_DefaultComparer_PostOrder_IsCorrect() { BinarySearchTree <string> tree = new BinarySearchTree <string>(new string[] { "1", "2", "3", "4" }); CollectionAssert.AreEqual(new string[] { "2", "3", "4", "1" }, tree.PostOrder()); }