コード例 #1
0
        public void CheckBalanced_Should_Check_Depth_False()
        {
            //arrange
            var tree = new MyBinarySearchTree <int>();

            tree.Insert(10);
            tree.Insert(6);
            tree.Insert(12);
            tree.Insert(4);
            tree.Insert(8);
            tree.Insert(11);
            tree.Insert(13);
            tree.Insert(3);
            tree.Insert(5);
            tree.Insert(7);
            tree.Insert(2);

            //act
            var result = _treesGraphs.CheckBalanced(tree);

            //assert
            result.ShouldBeEquivalentTo(false);
        }
コード例 #2
0
        public void PathsWithSum_Should_Check_Different_Depth()
        {
            //arrange
            var tree = new MyBinarySearchTree <int>();

            tree.Insert(10);
            tree.Insert(6);
            tree.Insert(15);
            tree.Insert(4);
            tree.Insert(8);
            tree.Insert(13);
            tree.Insert(17);
            tree.Insert(3);
            tree.Insert(5);
            tree.Insert(7);
            tree.Insert(14);
            tree.Insert(-10);

            //act
            var result = _treesGraphs.PathsWithSum(tree, 13);

            //assert
            result.ShouldBeEquivalentTo(3);
        }
コード例 #3
0
        public void CheckSubtree_Should_Check_Multiple_Depth_False()
        {
            //arrange
            var biggerTree  = new MyBinarySearchTree <int>();
            var smallerTree = new MyBinarySearchTree <int>();

            biggerTree.Insert(10);
            biggerTree.Insert(6);
            biggerTree.Insert(15);
            biggerTree.Insert(4);
            biggerTree.Insert(8);
            biggerTree.Insert(13);
            biggerTree.Insert(17);
            biggerTree.Insert(3);
            biggerTree.Insert(5);
            biggerTree.Insert(7);
            biggerTree.Insert(14);
            biggerTree.Insert(2);

            smallerTree.Root = biggerTree.Root.Left.Left;
            biggerTree.Root  = biggerTree.Root.Right;

            //act
            var result = _treesGraphs.CheckSubtree(biggerTree, smallerTree);

            //assert
            result.ShouldBeEquivalentTo(false);
        }
コード例 #4
0
        public void RandomNode_Should_Check_Multiple_Length()
        {
            //arrange
            var tree = new MyBinarySearchTree <int>();

            tree.Insert(10);
            tree.Insert(6);
            tree.Insert(15);
            tree.Insert(4);
            tree.Insert(8);
            tree.Insert(13);
            tree.Insert(17);
            tree.Insert(3);
            tree.Insert(5);
            tree.Insert(7);
            tree.Insert(14);
            tree.Insert(2);

            //act
            var result = _treesGraphs.RandomNode(tree);

            //assert
            tree.Contains(result.Data).ShouldBeEquivalentTo(true);
        }
コード例 #5
0
        public void BSTSequences_Should_Check_Complex()
        {
            //arrange
            var tree = new MyBinarySearchTree <int>();

            tree.Insert(10);
            tree.Insert(6);
            tree.Insert(15);
            tree.Insert(4);
            tree.Insert(8);
            tree.Insert(13);
            tree.Insert(17);
            tree.Insert(3);
            tree.Insert(5);
            tree.Insert(7);
            tree.Insert(14);
            tree.Insert(2);

            //act
            var result = _treesGraphs.BSTSequences(tree);

            //assert
            var inOrderTraversal = tree.InOrderTraversal().ToList();

            foreach (var item in result)
            {
                var tempTree = new MyBinarySearchTree <int>();
                foreach (var value in item)
                {
                    tempTree.Insert(value);
                }

                var tempTraversal = tempTree.InOrderTraversal().ToList();
                tempTraversal.Count.ShouldBeEquivalentTo(inOrderTraversal.Count);

                for (int i = 0; i < tempTraversal.Count; i++)
                {
                    tempTraversal[i].ShouldBeEquivalentTo(inOrderTraversal[i]);
                }
            }
        }