Drzewo RBT - usuwanie

Witam! Walczę z usuwaniem w drzewie binarnym typu czerwono czarnego. Nie wiem gdzie popełniłem błąd w funkcji wyszukującej następnika dla usuwanego węzła. Ta funkcja zwraca mi zawsze węzeł wskazujący na nic Druga sprawa nie wiem czy poprawnie zrobiłem samą implementację drzewa, bo u mnie liscie to wartości typu NULL a nie puste węzły czyli NIL.

 struct tnode /*wezel drzewa*/
    {
        string nazwisko, imie, adres;
        long int numer_komorkowy, numer_domowy, numer_do_pracy;
        int kolor; //0 czarny  1 czerowny
        tnode *lewy, *prawy, *p;
        ///konstruktor
        tnode()
        {
            nazwisko="";
            imie="";
            adres="";
            lewy=NULL;
            prawy=NULL;
            p=NULL;
        }
        tnode(string n, string i, string a, long int nk, long int nd, long int ndp)
        {
            nazwisko=n;
            imie=i;
            adres=a;
            numer_komorkowy=nk;
            numer_domowy=nd;
            numer_do_pracy=ndp;
            lewy=NULL;
            prawy=NULL;
            p=NULL;
            kolor=1;
        }
    };
    tnode *korzen;

 
 tnode *Tree_Succesor(tnode *x)
    {
        tnode *y;
        if(x->prawy!=NULL) {y = TreeMin(x->prawy); return y;}
        y=x->p;
        while((y!=NULL)&&(x==y->prawy))
        {
            x=y;
            y=y->p;
        }
        return y;
    }

    tnode *TreeMax(tnode *x)
    {
        while(x->prawy!=NULL)
        x=x->prawy;
        return x;
    }
/*--------------------------------------------------------------------*/
    tnode *TreeMin(tnode *x)
    {
        while(x->lewy!=NULL)
        x=x->lewy;
        return x;
    }

    void replace_node(tnode *x, tnode *y)
    {
        tnode *tmp=x;
        x->p=y->p;
        x->lewy=y->lewy;
        x->prawy=y->prawy;

        y->p=tmp->p;
        y->lewy=tmp->lewy;
        y->prawy=tmp->prawy;

        delete tmp;

    }

tnode *sibling(tnode *x)
    {
        if (cmp(x,x->p->lewy)==0)
                return x->p->prawy;
        else
                return x->p->lewy;
    }


  void delete_wezel(tnode *x)
    {
        /*
         * Precondition: n has at most one non-null child.
         */
        tnode *y = Tree_Succesor(x);

        if(x->prawy == NULL) y = x->lewy;
        else { y = x->prawy; }

        replace_node(x,y);
        if (x->kolor == 0) {
                if (y->kolor == 1)
                        y->kolor = 0;
                else
                        delete_case1(y);
        }
        delete x;
    }

    void delete_case1(tnode *x)
    {
        if (x->p != NULL)
                delete_case2(x);
    }

  void delete_case2(tnode *x)
    {
        tnode *y = sibling(x);

        if (y->kolor == 1) {
                x->p->kolor = 1;
                y->kolor = 0;
                if (x == x->p->lewy)
                        Left_Rotate(x->p);
                else
                        Right_Rotate(x->p);
        }
        delete_case3(x);
    }

    void delete_case3(tnode *x)
    {
        tnode *y = sibling(x);

        if ((x->p->kolor == 0) &&
            (y->kolor == 0) &&
            (y->lewy->kolor == 0) &&
            (y->prawy->kolor == 0)) {
                y->kolor = 1;
                delete_case1(x->p);
        } else
                delete_case4(x);
    }

  void delete_case4(tnode *x)
    {
        tnode *y = sibling(x);

        if ((x->p->kolor == 1) &&
            (y->kolor == 0) &&
            (y->lewy->kolor == 0) &&
            (y->prawy->kolor == 0)) {
                y->kolor = 1;
                x->p->kolor = 0;
        } else
                delete_case5(x);
    }

    void delete_case5(tnode *x)
    {
        tnode *y = sibling(x);

        if  (y->kolor == 0) {
                if ((x == x->p->lewy) &&
                    (y->prawy->kolor == 0) &&
                    (y->lewy->kolor == 1)) { /* this last test is trivial too due to cases 2-4. */
                        y->kolor = 1;
                        y->lewy->kolor = 0;
                        Right_Rotate(y);
                } else if ((x == x->p->prawy) &&
                           (y->lewy->kolor == 0) &&
                           (y->prawy->kolor == 1)) {/* this last test is trivial too due to cases 2-4. */
                        y->kolor = 1;
                        y->prawy->kolor = 0;
                        Left_Rotate(y);
                }
        }
        delete_case6(x);
    }

  void delete_case6(tnode *x)
    {
        tnode *y = sibling(x);

        y->kolor = x->p->kolor;
        x->p->kolor = 0;

        if (x == x->p->lewy) {
                y->prawy->kolor = 0;
                Left_Rotate(x->p);
        } else {
                y->lewy->kolor = 0;
                Right_Rotate(x->p);
        }
    }