public void BinomialMaxHeap_Test()
        {
            int nodeCount = 1000 * 10;
            //insert test
            var tree = new BinomialMaxHeap <int>();

            for (int i = 0; i <= nodeCount; i++)
            {
                tree.Insert(i);
            }

            for (int i = 0; i <= nodeCount; i++)
            {
                tree.IncrementKey(i, i + 1);
            }
            int max = 0;

            for (int i = nodeCount; i >= 0; i--)
            {
                max = tree.ExtractMax();
                Assert.AreEqual(max, i + 1);
            }

            //IEnumerable tests.
            Assert.AreEqual(tree.Count, tree.Count());

            var rnd        = new Random();
            var testSeries = Enumerable.Range(0, nodeCount - 1).OrderBy(x => rnd.Next()).ToList();

            foreach (var item in testSeries)
            {
                tree.Insert(item);
            }

            for (int i = 0; i < testSeries.Count; i++)
            {
                var incremented = testSeries[i] + rnd.Next(0, 1000);
                tree.IncrementKey(testSeries[i], incremented);
                testSeries[i] = incremented;
            }

            testSeries = testSeries.OrderByDescending(x => x).ToList();

            for (int i = 0; i < nodeCount - 2; i++)
            {
                max = tree.ExtractMax();
                Assert.AreEqual(testSeries[i], max);
            }

            //IEnumerable tests.
            Assert.AreEqual(tree.Count, tree.Count());
        }
        public void BinomialMaxHeap_Test()
        {
            int nodeCount = 1000 * 10;
            //insert test
            var tree = new BinomialMaxHeap <int>();

            var nodePointers = new List <BinomialHeapNode <int> >();

            for (int i = 0; i <= nodeCount; i++)
            {
                var node = tree.Insert(i);
                nodePointers.Add(node);
                var theoreticalTreeCount = Convert.ToString(i + 1, 2).Replace("0", "").Length;
                var actualTreeCount      = tree.heapForest.Count();

                Assert.AreEqual(theoreticalTreeCount, actualTreeCount);
            }

            for (int i = 0; i <= nodeCount; i++)
            {
                nodePointers[i].Value++;
                tree.IncrementKey(nodePointers[i]);
            }
            int max = 0;

            for (int i = nodeCount; i >= 0; i--)
            {
                max = tree.ExtractMax();
                Assert.AreEqual(i + 1, max);
            }

            nodePointers.Clear();

            var rnd        = new Random();
            var testSeries = Enumerable.Range(0, nodeCount - 1).OrderBy(x => rnd.Next()).ToList();


            foreach (var item in testSeries)
            {
                nodePointers.Add(tree.Insert(item));
            }

            max          = tree.ExtractMax();
            nodePointers = nodePointers.Where(x => x.Value != max).ToList();
            var resultSeries = new List <int>();

            for (int i = 0; i < nodePointers.Count; i++)
            {
                nodePointers[i].Value = nodePointers[i].Value + rnd.Next(0, 1000);
                tree.IncrementKey(nodePointers[i]);
            }

            foreach (var item in nodePointers)
            {
                resultSeries.Add(item.Value);
            }

            resultSeries = resultSeries.OrderByDescending(x => x).ToList();

            for (int i = 0; i < nodeCount - 2; i++)
            {
                max = tree.ExtractMax();
                Assert.AreEqual(resultSeries[i], max);
            }
        }