Beispiel #1
0
        /// <summary>
        ///     Inserts the given node underneath the given root according to the BinarySearchTree algorithm and then
        ///     rebalances the tree according to the red-black tree rules
        /// </summary>
        /// <param name="root">The root node of the tree</param>
        /// <param name="node">The node to insert</param>
        /// <returns>The new root of the tree as it may have changed</returns>
        private (RedBlackNode <RbLineSegment> root, RbLineSegment higher, RbLineSegment lower) InsertBracketed(RedBlackNode <RbLineSegment> root, RedBlackNode <RbLineSegment> node)
        {
            RbLineSegment higher = null;
            RbLineSegment lower  = null;

            if (root == null)
            {
                root = node;
                ++Count;
            }
            else
            {
                root.ResetHeight();
                var compareResult = root.Value.CompareTo(node.Value);
                if (compareResult > 0)
                {
                    (root.Left, higher, lower) = InsertBracketed(root.Left, node);
                    if (higher == null && lower == null)
                    {
                        node.Value.NextHigher = higher = root.Value;
                        node.Value.NextLower  = lower = root.Value.NextLower;
                        higher.NextLower      = node.Value;
                        if (lower != null)
                        {
                            lower.NextHigher = node.Value;
                        }
                    }
                }
                else if (compareResult < 0)
                {
                    (root.Right, higher, lower) = InsertBracketed(root.Right, node);
                    if (higher == null && lower == null)
                    {
                        node.Value.NextLower  = lower = root.Value;
                        node.Value.NextHigher = higher = root.Value.NextHigher;
                        lower.NextHigher      = node.Value;
                        if (higher != null)
                        {
                            higher.NextLower = node.Value;
                        }
                    }
                }
                else
                {
                    throw new ArgumentException("Inserting duplicate in Red Black tree");
                }
            }

            root = PostInsertCleanup(root, node);

            return(root, higher, lower);
        }
Beispiel #2
0
        public void ResetHeight()
        {
            RedBlackNode <int> node = new RedBlackNode <int>(20);

            Assert.AreEqual <int>(0, node.Height);

            node.Left = new RedBlackNode <int>(10);

            Assert.AreEqual <int>(0, node.Height);

            node.ResetHeight();

            Assert.AreEqual <int>(1, node.Height);
        }
Beispiel #3
0
        public void RotateRight_FullTree()
        {
            RedBlackNode <int> node = new RedBlackNode <int>(100);

            node.Left  = new RedBlackNode <int>(50);
            node.Right = new RedBlackNode <int>(150);

            node.Left.Left   = new RedBlackNode <int>(25);
            node.Left.Right  = new RedBlackNode <int>(75);
            node.Right.Left  = new RedBlackNode <int>(125);
            node.Right.Right = new RedBlackNode <int>(175);

            node.ResetHeight();
            node.Left.ResetHeight();
            node.Right.ResetHeight();
            node.Left.Left.ResetHeight();
            node.Left.Right.ResetHeight();
            node.Right.Left.ResetHeight();
            node.Right.Right.ResetHeight();

            node = node.RotateRight() as RedBlackNode <int>;

            Assert.AreEqual <int>(50, node.Value);
            Assert.AreEqual <int>(25, node.Left.Value);
            Assert.AreEqual <int>(100, node.Right.Value);
            Assert.AreEqual <int>(75, node.Right.Left.Value);
            Assert.AreEqual <int>(150, node.Right.Right.Value);
            Assert.AreEqual <int>(125, node.Right.Right.Left.Value);
            Assert.AreEqual <int>(175, node.Right.Right.Right.Value);


            Assert.AreEqual <int>(3, node.Height);
            Assert.AreEqual <int>(0, node.Left.Height);
            Assert.AreEqual <int>(2, node.Right.Height);
            Assert.AreEqual <int>(1, node.Right.Right.Height);
            Assert.AreEqual <int>(0, node.Right.Left.Height);
            Assert.AreEqual <int>(0, node.Right.Right.Right.Height);
            Assert.AreEqual <int>(0, node.Right.Right.Left.Height);
        }
Beispiel #4
0
        public void RotateRight_FullTree()
        {
            RedBlackNode<int> node = new RedBlackNode<int>(100);

            node.Left = new RedBlackNode<int>(50);
            node.Right = new RedBlackNode<int>(150);

            node.Left.Left = new RedBlackNode<int>(25);
            node.Left.Right = new RedBlackNode<int>(75);
            node.Right.Left = new RedBlackNode<int>(125);
            node.Right.Right = new RedBlackNode<int>(175);

            node.ResetHeight();
            node.Left.ResetHeight();
            node.Right.ResetHeight();
            node.Left.Left.ResetHeight();
            node.Left.Right.ResetHeight();
            node.Right.Left.ResetHeight();
            node.Right.Right.ResetHeight();

            node = node.RotateRight() as RedBlackNode<int>;

            Assert.AreEqual<int>(50, node.Value);
            Assert.AreEqual<int>(25, node.Left.Value);
            Assert.AreEqual<int>(100, node.Right.Value);
            Assert.AreEqual<int>(75, node.Right.Left.Value);
            Assert.AreEqual<int>(150, node.Right.Right.Value);
            Assert.AreEqual<int>(125, node.Right.Right.Left.Value);
            Assert.AreEqual<int>(175, node.Right.Right.Right.Value);

            Assert.AreEqual<int>(3, node.Height);
            Assert.AreEqual<int>(0, node.Left.Height);
            Assert.AreEqual<int>(2, node.Right.Height);
            Assert.AreEqual<int>(1, node.Right.Right.Height);
            Assert.AreEqual<int>(0, node.Right.Left.Height);
            Assert.AreEqual<int>(0, node.Right.Right.Right.Height);
            Assert.AreEqual<int>(0, node.Right.Right.Left.Height);
        }
Beispiel #5
0
        public void ResetHeight()
        {
            RedBlackNode<int> node = new RedBlackNode<int>(20);

            Assert.AreEqual<int>(0, node.Height);

            node.Left = new RedBlackNode<int>(10);

            Assert.AreEqual<int>(0, node.Height);

            node.ResetHeight();

            Assert.AreEqual<int>(1, node.Height);
        }