コード例 #1
0
        public void Consolidate_LargeNumberOfSiblings(int[] sequence)
        {
            var siblings = CreateSiblings(sequence);
            var count    = NodeDebugTools <int> .IterateSiblings(siblings).Count();

            Assert.AreEqual(sequence.Length, count);

            var consolidated = _heap.Consolidate(siblings, count);

            var consolidatedCount = NodeDebugTools <int> .IterateSiblings(consolidated).Count();

            Assert.AreEqual(1, consolidatedCount);
        }
コード例 #2
0
        public void Consolidate_LotsOfNodes_CorrectWidth()
        {
            var tree1 = CreateTree(new int[] { 1 });
            var tree2 = CreateTree(new int[] { 2 });
            var tree3 = CreateTree(new int[] { 3, 4 });

            _heap.Join(tree1, tree2);
            _heap.Join(tree1, tree3);

            var consolidated = _heap.Consolidate(tree1, 3);

            var enumeratedSiblings = NodeDebugTools <int> .IterateSiblings(consolidated);

            Assert.AreEqual(1, enumeratedSiblings.Count());
        }
コード例 #3
0
        public void Iterate_Siblings_Success()
        {
            var p1 = FibonacciHeapTestHelpers.CreateNodeConnectedToSelf(1);
            var p2 = FibonacciHeapTestHelpers.CreateNodeConnectedToSelf(2);
            var p3 = FibonacciHeapTestHelpers.CreateNodeConnectedToSelf(3);

            _heap.Join(p2, p3);
            _heap.Join(p1, p2);

            var actual = NodeDebugTools <int> .IterateSiblings(p1).ToList();

            Assert.Multiple(() =>
            {
                Assert.AreEqual(3, actual.Count());
                Assert.AreEqual(1, actual[0].Value);
                Assert.AreEqual(2, actual[1].Value);
                Assert.AreEqual(3, actual[2].Value);
            });
        }