Exemple #1
0
        private void CorrectCase5(RBNode n)
        {
            RBNode g = n.Grandparent();

            n.parent.Color = RBColor.Black;
            g.Color        = RBColor.Red;

            /*      g,к
             *     /    \
             *    p,ч    u,ч
             *   /
             *  n,к
             *  (n1)
             */
            if ((n == n.parent.left) && (n.parent == g.left))
            {
                RotateRight(g);
            }

            /*        g,к
             *      /   \
             *           p,ч
             *            \
             *             n,k
             */
            else if ((n == n.parent.right) && (n.parent == g.right))
            {
                RotateLeft(g);
            }
        }
Exemple #2
0
        private void CorrectCase3(RBNode n)
        {
            // Дерево непустое, значитродитель точно есть
            if (n.parent == null)
            {
                throw new NullReferenceException("У узла точно прям 100500 должен быть родитель");
            }

            RBNode u = n.Uncle();

            /*   Оба потомка каждого красного узла не черные (правый или левый родитель или узел не важно)
             *   дядя сущ. и красный (родитель тож красный из 2 кейса)
             *          g, ч                       g, к
             *         /    \                     /     \
             *       p, к    u, к     =>         р, ч    u, ч
             *      /    \                      /    \
             *     n, к                        n, к
             */
            if ((u != null) && (u.Color == RBColor.Red)) // && (n->parent->color == RED)
                                                         // Второе условие проверяется в AddNodeCase2,
                                                         // то есть родитель уже является красным.
            {
                n.parent.Color = RBColor.Black;
                u.Color        = RBColor.Black;
                RBNode g = n.Grandparent();
                g.Color = RBColor.Red;
                CorrectCase1(g);
            }
            else // дядя не сущ или черный
            {
                CorrectCase4(n);
            }
        }
Exemple #3
0
        private void CorrectCase4(RBNode n)
        {
            // Дерево непустое, значитродитель точно есть
            if (n.parent == null)
            {
                throw new NullReferenceException("У узла точно прям 100500 должен быть родитель");
            }

            RBNode g = n.Grandparent();

            // И т.к родитель красный, то дед точно есть, потому что корень всегда черный и р не мб корнем
            if (g == null)
            {
                throw new NullReferenceException("У узла точно прям 100500 должен быть дед ибо родитель красный");
            }

            RBNode n1 = n;

            // дядя не сущ или черный (родитель красный)

            /*       g,ч                    g,2
             *     /    \         или      /    \
             *    p,к    u,ч              u,2    p, k   (с этим ничего не делаем)
             *   /  \                            /   \
             *       n,к                             n,k
             *                 стало:
             *      g,ч                    g,2
             *     /    \         или     /    \
             *    n,к    u,ч            u,2    p,k
             *   /                                \
             *  p,к                               n,k
             *  (n1)                             (n1)
             */
            if ((n == n.parent.right) && (n.parent == g.left))
            /*|| ((n == n.parent.right) && (n.parent == g.right)) - с этим ничего не делаем. кейс 5 все сделает*/
            {
                RotateLeft(n.parent);
                n1 = n.left;
            }

            /*      g,ч                  g,2
             *     /    \        или    /   \
             *    u,ч   p,к            p,k   u,2
             *          /  \          /  \
             *         n,к           n,k
             *
             *                 стало:
             *
             *      g,ч                  g,2
             *     /    \        или     /   \
             *    u,ч   n,к             p,k   u,2
             *            \            /
             *            p,к         n,k
             *            (n1)        (n1)
             */
            else if ((n == n.parent.left) && (n.parent == g.right))
            //   || ((n == n.parent.left) && (n.parent == g.left)) - с этим тож ничего не делаем
            {
                RotateRight(n.parent);
                n1 = n.right;
            }
            CorrectCase5(n1);
        }