//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());
        }
Beispiel #3
0
        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);
        }
Beispiel #4
0
        //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();
        }
Beispiel #5
0
        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);
		}
Beispiel #7
0
        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());
        }
Beispiel #8
0
        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);
        }
Beispiel #11
0
        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);
 }
Beispiel #16
0
        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());
            }
        }
Beispiel #17
0
        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);
        }
Beispiel #19
0
        static void Main(string[] args)
        {
            BinarySearchTree<string> tree = new BinarySearchTree<string>()
            {
                new TreeNode<string>("first")

            };
        }
Beispiel #20
0
 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);
        }
Beispiel #31
0
 public static void Insert(this BinarySearchTree <int> tree, int val)
 {
 }
Beispiel #32
0
    public void Data_is_retained()
    {
        var tree = new BinarySearchTree(4);

        Assert.That(tree.Value, Is.EqualTo(4));
    }
Beispiel #33
0
        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);
        }
Beispiel #34
0
        public void ExceptionSetInvalidKey()
        {
            var tree = new BinarySearchTree <int, string>();

            tree[4] = "testString";
        }
Beispiel #35
0
 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;
 }
Beispiel #38
0
        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());
        }
Beispiel #39
0
 public void TestFindMin_EmptyException()
 {
     BinarySearchTree <int> bst = new BinarySearchTree <int>();
     int min = bst.Min;
 }
Beispiel #40
0
        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));
        }
Beispiel #41
0
        public void TestFindMax()
        {
            BinarySearchTree <int> bst = GetRandomTree();

            Assert.That(bst.Max, Is.EqualTo(GetRandomArray().Max()));
        }
Beispiel #42
0
        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));
        }
Beispiel #44
0
        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();
        }
Beispiel #45
0
        public void CanSuccessfullyInstantiateAnEmptyTree()
        {
            BinarySearchTree <char> binarySearchTree = new BinarySearchTree <char>();

            Assert.NotNull(binarySearchTree);
        }
Beispiel #46
0
        public void TestInsert_DuplicateItemException()
        {
            BinarySearchTree <int> bst = GetRandomTree();

            bst.Insert(GetRandomArray().First());
        }
Beispiel #47
0
 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());
        }
Beispiel #49
0
    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 }));
    }
Beispiel #50
0
        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();
        }
Beispiel #51
0
    public void Iterating_over_larger_element()
    {
        var elements = new BinarySearchTree(new[] { 4, 5 }).AsEnumerable();

        Assert.That(elements, Is.EqualTo(new[] { 4, 5 }));
    }
Beispiel #52
0
        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);
        }
Beispiel #55
0
        public void TestRemoveMin_ElementNotFoundException()
        {
            BinarySearchTree <int> emptyTree = new BinarySearchTree <int>();

            emptyTree.RemoveMin();
        }
Beispiel #56
0
        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>();
 }
Beispiel #58
0
 public void TestFindMax_EmptyException()
 {
     BinarySearchTree <int> bst = new BinarySearchTree <int>();
     int max = bst.Max;
 }
Beispiel #59
0
 public BstTester()
 {
     Output = $"BST Tester: {CommandText}";
     _tree  = new BinarySearchTree <int>();
 }
Beispiel #60
0
        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());
        }