Accord.Tests.Math.RedBlackTreeTest.run C# (CSharp) Method

        private static void run(int n)
        {
            var rand = Accord.Math.Tools.Random;

            RedBlackTree<int> t = new RedBlackTree<int>(allowDuplicates: true);

            // Create a vector of random numbers
            int[] k = new int[n];
            for (int i = 0; i < k.Length; i++)
                k[i] = rand.Next(k.Length);

            int[] sorted = (int[])k.Clone();
            Array.Sort(sorted);

            // Populate the tree with numbers
            for (int i = 0; i < k.Length; i++)
            {
                var node = t.Add(k[i]);

                Assert.IsNotNull(node);
                Assert.AreEqual(k[i], node.Value);

                Assert.IsTrue(t.check());
            }

            Assert.AreEqual(k.Length, t.Count);


            // Check that all elements are in the tree
            for (int i = 0; i < k.Length; ++i)
            {
                var node = t.Find(k[i]);

                Assert.IsNotNull(node);
                Assert.AreEqual(k[i], node.Value);

                Assert.IsTrue(t.Contains(k[i]));
                Assert.IsTrue(t.Contains(node));
            }

            // Enumerate the values (must be in order)
            int arrayIndex = 0;
            foreach (var node in t)
                Assert.AreEqual(sorted[arrayIndex++], node.Value);



            // Start from min and go navigating up to max
            var min = t.Min();
            Assert.IsNotNull(min);
            Assert.AreEqual(k.Min(), min.Value);

            for (int i = 0; i < k.Length; i++)
            {
                Assert.IsNotNull(min);
                min = t.GetNextNode(min);
            }
            Assert.IsNull(min); // the last should be null.

            // Start from max and go navigating down to min
            var max = t.Max();
            Assert.AreEqual(k.Max(), max.Value);
            for (int i = 0; i < k.Length; i++)
            {
                Assert.IsNotNull(max);
                max = t.GetPreviousNode(max);
            }
            Assert.IsNull(max); // the last should be null.


            // Exercise the tree
            for (int M = k.Length; M > 0; M--)
            {
                int knew = rand.Next(k.Length); // random new key 
                int j = rand.Next(M); // random original key to replace 
                int i;

                for (i = 0; i < k.Length; i++)
                    if (k[i] >= 0)
                        if (j-- == 0)
                            break;


                if (i >= k.Length)
                    Assert.Fail();

                int kd = k[i];

                var node = t.Find(kd);
                Assert.IsNotNull(node);

                node.Value = knew;

                Assert.IsNotNull(t.Resort(node));
                Assert.IsTrue(t.check());

                k[i] = -1 - knew;

                Assert.AreEqual(k.Length, t.Count);
            }

            for (int i = 0; i < k.Length; i++)
                k[i] = -1 - k[i]; // undo negation above




            // check the localization functions
            for (int i = 0; i < k.Length; i++)
            {
                int kd = (int)(0.01 * (rand.Next() % (k.Length * 150) - k.Length * 25));

                var le = t.FindLessThanOrEqualTo(kd);
                var gt = t.FindGreaterThan(kd);

                var node = t.Min();

                double lek = le != null ? le.Value : int.MinValue;
                double gtk = gt != null ? gt.Value : int.MaxValue;


                if (node.Value > kd)
                {
                    Assert.IsNull(le);
                    Assert.IsNotNull(gt);
                    Assert.AreEqual(gt, node);
                }
                else
                {
                    var succ = node;
                    do
                    {
                        node = succ;
                        succ = t.GetNextNode(node);
                    } while (succ != null && succ.Value <= kd);

                    Assert.AreEqual(node, le);
                    Assert.AreEqual(succ, gt);
                }
            }

            // Remove elements from the tree
            for (int M = k.Length; M > 0; M--)
            {
                int j = rand.Next() % M;
                int i;
                for (i = 0; i < k.Length; i++)
                    if (k[i] >= 0)
                        if (j-- == 0)
                            break;

                if (i >= k.Length)
                    Assert.Fail();

                int kd = k[i];

                var node = t.Find(kd);
                Assert.IsNotNull(node);

                node = t.Remove(node);
                Assert.IsTrue(t.check());

                k[i] = -1 - k[i];
            }

            // The tree should be empty
            Assert.AreEqual(0, t.Count);
        }