Drzewo BST- problem z wypisywaniem

0

Cześć

Rozpocząłem zabawę z drzewami i niestety słabo mi to wychodzi. Otóż dodaję do drzewa nowe węzły z zawartością i wszystko jest ok. Ładnie się dodają, jednak przy wypisaniu drzewa otrzymuję ostatnio wstawiony element, zamiast całego drzewa. Nie wiem gdzie leży przyczyna takiego zachowania. Czy może nie dodaję innych węzłów czy może one gdzieś po drodze giną. Proszę o pomoc, gdyż w takiej sytuacji tzn. szukania już przez jakiś czas być może nie zauważam oczywistej przyczyny.

#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <list>
using namespace std;

typedef enum {RED,BLACK} COLOR;
//typedef struct tnode *Treewsk;
class ksiazka
{

    struct tnode /*wezel drzewa*/
    {
        string nazwisko, imie, adres;
        long int numer_komorkowy, numer_domowy, numer_do_pracy;
        COLOR kolor;
        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=(COLOR)1;
        }

    };

    tnode *korzen;

    public:
        ksiazka() {  korzen=NULL;  }
        ~ksiazka() {}

    void wypisz_drzewo()
    {
        cout<<"Nasze drzewo "<<endl;
        wypisz_all(korzen);
    }

    void wypisz_all(tnode *w)
        {
            if(w!=NULL)
            {
                wypisz_all(w->lewy);
                cout<<w->nazwisko<<" "<<w->imie<<" "<<w->adres;
                wypisz_all(w->prawy);
            }
        }

    void wypisz(tnode *w)
        {
                cout<<w->nazwisko<<" "<<w->imie<<" "<<w->adres<<endl;
        }


    bool szukaj(tnode* n)
    {

        while(korzen)
        {
            if(korzen->nazwisko == n->nazwisko && korzen->imie==n->imie && korzen->adres==n->adres) {return true;}
            else
            {
                if(korzen->nazwisko == n->nazwisko)
                {
                    if(korzen->imie==n->imie)
                    {
                        if(korzen->adres < korzen->adres)
                        {
                            korzen=korzen->prawy;
                        }
                        else
                        {
                            korzen=korzen->lewy;
                        }
                    }
                    else if (korzen->imie < n->imie)
                    korzen=korzen->prawy;
                    else
                    korzen=korzen->lewy;
                }
                else if (korzen->nazwisko < n->nazwisko)
                korzen=korzen->prawy;
                else
                korzen=korzen->lewy;
            }
        }
        return false;
    }


tnode *dodaj()
{
    string naz="",im="",adr="";
    long int nk, nd, ndp;
    cout<<"Podaj nazwisko"<<endl;
    cin>>naz;
    cout<<"Podaj imie"<<endl;
    cin>>im;
    cout<<"Podaj adres"<<endl;
    getline(cin,adr,'\n');
    cout<<"Podaj numer komorkowy"<<endl;
    cin>>nk;
    cout<<"Podaj numer domowy"<<endl;
    cin>>nd;
    cout<<"Podaj numer do pracy "<<endl;
    cin>>ndp;

    tnode *nowy = new  tnode(naz, im, adr, nk, nd, ndp);
    wypisz(nowy);
    getch();
    return nowy;
}

void insert_bst()
{
    
    if(korzen==NULL)
    {
        tnode *nowy=dodaj();
        korzen=nowy;
        korzen->p=NULL;
        korzen->lewy=NULL;
        korzen->prawy=NULL;
        return;
    }
    else
    {
        tnode *tmp=korzen;
        tnode *n=dodaj();
        if(szukaj(n)) {cout<<"znaleziono DUPLIKAT!!!"<<endl; return;}
          while(tmp->lewy!=NULL || tmp->prawy!=NULL)
        {
            //if(korzen->nazwisko == n->nazwisko && korzen->imie==n->imie && korzen->adres==n->adres) {return true;}
            //else
                if(tmp->nazwisko == n->nazwisko)
                {
                    if(tmp->imie==n->imie)
                    {
                        if(tmp->adres < tmp->adres)
                        {
                            tmp=tmp->prawy;
                        }
                        else
                        {
                            tmp=tmp->lewy;
                        }
                    }
                    else if (tmp->imie < n->imie)
                    tmp=tmp->prawy;
                    else
                    tmp=tmp->lewy;
                }
                else if (tmp->nazwisko < n->nazwisko)
                tmp=tmp->prawy;
                else
                tmp=tmp->lewy;
        }

        n->p=tmp;
          if(tmp->nazwisko.compare(n->nazwisko) == 0)
                {
                    if(tmp->imie.compare(n->imie)==0)
                    {
                        if(tmp->adres < tmp->adres)
                        {
                           tmp->prawy=n;
                        }
                        else
                        {
                           tmp->lewy=n;
                        }
                        return;
                    }
                    else if (tmp->imie < n->imie)
                    tmp->prawy=n;
                    else
                    tmp->lewy=n;
                }
                else if (tmp->nazwisko < n->nazwisko)
                tmp->prawy=n;
                else
                tmp->lewy=n;
    }
}

bool Szukaj_nazwisko(string s)
{
    tnode *x=korzen;
  while((x!=NULL)&&(s !=x->nazwisko))
    if(s < x->nazwisko)x=x->lewy;
    else x=x->prawy;
  if(s == x->nazwisko )return 1;
  else return 0;
}

};

int main()
{

    ksiazka ksioo;
    ksioo.insert_bst();
     cout << "dodano" << endl;
    getch();
    ksioo.insert_bst();
    cout << "dodano" << endl;
    getch();
    ksioo.insert_bst();
    cout << "dodano" << endl;
    getch();
    ksioo.wypisz_drzewo();
    getch();
    cout << "Hello world!" << endl;
    return 0;
} 
0

Strasznie nakombinowałeś. Może napisz funkcję/metodę int cmp(tnode *A,tnode *B); potem uprość całość :D

0

Poprawiłem funkcję szukaj(); Działa :D

   bool szukaj(tnode* n)
    {
        tnode *tmp=korzen;
        while(tmp)
        {
            if(tmp->nazwisko == n->nazwisko && tmp->imie==n->imie && tmp->adres==n->adres) {return true;}
            else
            {
                if(tmp->nazwisko == n->nazwisko)
                {
                    if(tmp->imie==n->imie)
                    {
                        if(tmp->adres < tmp->adres)
                        {
                            tmp=tmp->prawy;
                        }
                        else
                        {
                            tmp=tmp->lewy;
                        }
                    }
                    else if (tmp->imie < n->imie)
                    tmp=tmp->prawy;
                    else
                    tmp=tmp->lewy;
                }
                else if (tmp->nazwisko < n->nazwisko)
                tmp=tmp->prawy;
                else
                tmp=tmp->lewy;
            }
        }
        delete tmp;
        return false;
    }
0

Ale masz wycieki pamięci, zrób tak jak powiedziałem a znajdziesz.

0

szukaj(korzen,n) - korzen to wiadomo, a n to nowo utworzony obiekt

 bool szukaj(tnode *tmp, tnode *n)
    {
           if(tmp!=NULL)
            {
                if(tmp->nazwisko == n->nazwisko && tmp->imie==n->imie && tmp->adres==n->adres) {return true;}
                 else
               {
                   szukaj(tmp->prawy,n);
                   szukaj(tmp->lewy,n);
               }
            }

        return false;
    }

Lepiej? Nie wiem czemu wyglądało o jak wyglądało, skoro nie obchodziła mnie jednoznaczność poszczególnych danych tylko całego węzła.

EDIT Nie no dalej jest źle. Muszę lepiej to przemyśleć.

0

Absolutnie nie, po kiego przeszukujesz całe drzewo, przecież masz uporządkowane? Nadal nie zlikwidowałeś wycieku pamięci. Nadal nie zrobiłeś tej funkcji porównującej.

0
#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <list>
using namespace std;

typedef enum {RED,BLACK} COLOR;

class ksiazka
{

    struct tnode /*wezel drzewa*/
    {
        string nazwisko, imie, adres;
        long int numer_komorkowy, numer_domowy, numer_do_pracy;
        COLOR kolor;
        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=(COLOR)1;
        }

    };

    tnode *korzen;

    public:
        ksiazka() {  korzen=NULL;  }
        ~ksiazka() {}

    void wypisz_drzewo()
    {
        cout<<"Nasze drzewo "<<endl;
        wypisz_all(korzen);
    }

    void wypisz_all(tnode *w)
        {
            if(w!=NULL)
            {
                wypisz_all(w->lewy);
                cout<<w->nazwisko<<" "<<w->imie<<" "<<w->adres<<endl;
                wypisz_all(w->prawy);
            }
        }

    void wypisz(tnode *w)
        {
                cout<<w->nazwisko<<" "<<w->imie<<" "<<w->adres<<endl;
        }


    int cmp(tnode* n)
    {
        tnode *tmp=korzen;
        while(tmp->lewy!=NULL || tmp->prawy!=NULL)
        {
            if(tmp->nazwisko == n->nazwisko && tmp->imie==n->imie && tmp->adres==n->adres) {return 1;}
            else
            {
                if(tmp->nazwisko == n->nazwisko)
                {
                    if(tmp->imie==n->imie)
                    {
                        if(tmp->adres < n->adres)
                        {
                            tmp=tmp->prawy;
                        }
                        else
                        {
                            tmp=tmp->lewy;
                        }
                    }
                    else if (tmp->imie < n->imie)
                    tmp=tmp->prawy;
                    else
                    tmp=tmp->lewy;
                }
                else if (tmp->nazwisko < n->nazwisko)
                tmp=tmp->prawy;
                else
                tmp=tmp->lewy;
            }
        }
        delete tmp;
        return 0;
    }

void insert_bst(string naz, string im, string adr,long int nk,long int nd, long int ndp)
{
    tnode *n = new  tnode(naz, im, adr, nk, nd, ndp);
    wypisz(n);
    getch();
    if(korzen==NULL)
    {
        korzen=n;
        korzen->p=NULL;
        korzen->lewy=NULL;
        korzen->prawy=NULL;
    }
    else
    {
        tnode *tmp=korzen;
        //if(cmp(n)) {cout<<"znaleziono DUPLIKAT!!!"<<endl; return;}
          while(!tmp)
        {
            //if(korzen->nazwisko == n->nazwisko && korzen->imie==n->imie && korzen->adres==n->adres) {return true;}
            //else
                if(tmp->nazwisko == n->nazwisko)
                {
                    if(tmp->imie==n->imie)
                    {
                        if(tmp->adres < n->adres)
                        {
                            if (!tmp->lewy) break;
                            tmp=tmp->prawy;
                        }
                        else
                        {
                             if (!tmp->lewy) break;
                            tmp=tmp->lewy;
                        }
                    }
                    else if (tmp->imie < n->imie)
                    tmp=tmp->prawy;
                    else
                    tmp=tmp->lewy;
                }
                else if (tmp->nazwisko < n->nazwisko)
                tmp=tmp->prawy;
                else
                tmp=tmp->lewy;
        }

        n->p=tmp;
          if(tmp->nazwisko.compare(n->nazwisko) == 0)
                {
                    if(tmp->imie.compare(n->imie)==0)
                    {
                        if(tmp->adres < n->adres)
                        {
                           tmp->prawy=n;
                        }
                        else
                        {
                           tmp->lewy=n;
                        }
                    }
                    else if (tmp->imie < n->imie)
                    tmp->prawy=n;
                    else
                    tmp->lewy=n;
                }
                else if (tmp->nazwisko < n->nazwisko)
                tmp->prawy=n;
                else
                tmp->lewy=n;

    }
delete n;
}

};

int main()
{
    ksiazka ksioo;
    ksioo.insert_bst("a","b","d",45,45,45);
    cout << "dodano" << endl;
    getch();
    ksioo.insert_bst("a","a","a",45,45,45);
    cout << "dodano" << endl;
    getch();
    ksioo.insert_bst("a","a","c",45,45,45);
    cout << "dodano" << endl;
    getch();
    ksioo.wypisz_drzewo();
    getch();
    cout << "Hello world!" << endl;
    return 0;
}
 

Trochę uproszczone, jednak nie działa wcale.

0

"Może napisz funkcję/metodę int cmp(tnode *A,tnode *B);" - funkcja ma porównać dwa rekordy i zwrócić:
wartość ujemną - jeżeli A < B
0 - jeżeli A=B
wartość dodatnią - jeżeli A > B

W szukaj oraz w insert_bst używasz jej tak:
int v=cmp(n,tmp);
if(v>0) //w prawo
else if(v<0) //w lewo
else // znaleziono identyczny

0

Docelowo chyba chodzi o coś takiego? Sprawdzam po kolei każdy z 3 czynników mających wpływ na rozplanowanie w drzewie.

   int cmp(tnode* p, tnode* n)
    {
        
            if(p->nazwisko == n->nazwisko && p->imie==n->imie && p->adres==n->adres) {return 0;}
            else
            {
                if(p->nazwisko == n->nazwisko)
                {
                    if(p->imie==n->imie)
                    {
                        if(p->adres < n->adres)
                        {
                            return -1;
                        }
                        else
                        {
                            return 1;
                        }
                    }
                    else if(p->imie < n->imie)
                        {
                            return -1;
                        }
                        else
                        {
                            return 1;
                        }
                }
                else if(p->nazwisko < n->nazwisko)
                    {
                        return -1;
                    }
                    else
                    {
                        return  1;
                    }
                    
            }
        
    } 
1

Nie możesz po ludzku?

int cmp(tnode* p, tnode* n)
  {
   int ret;   
   if((ret=p->nazwisko.compare(n->nazwisko))!=0) return ret; // można (p->nazwisko>n->nazwisko)-(p->nazwisko<n->nazwisko);
   if((ret=p->imie.compare(n->imie))!=0) return ret;
   return p->adres.compare(n->adres);
  }
0

Nie wiem już, co mam dalej źle, dla wstawiania tych danych przykładowych. Debbuger zatrzymuje mi się w pętli znajdującej się w insercie;

EDIT: Jednak zły warunek dałem w pętli. Co nie zmienia faktu iż dalej jest coś nie halo.

#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <list>
using namespace std;

typedef enum {RED,BLACK} COLOR;

class ksiazka
{
    struct tnode /*wezel drzewa*/
    {
        string nazwisko, imie, adres;
        long int numer_komorkowy, numer_domowy, numer_do_pracy;
        COLOR kolor;
        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=(COLOR)1;
        }
    };
    tnode *korzen;

    public:
        ksiazka() {  korzen=NULL;  }
        ~ksiazka() {}

    void wypisz_drzewo()
    {
        cout<<"Nasze drzewo "<<endl;
        wypisz_all(korzen);
    }

    void wypisz_all(tnode *w)
        {
            if(w!=NULL)
            {
                wypisz_all(w->lewy);
                cout<<w->nazwisko<<" "<<w->imie<<" "<<w->adres<<endl;
                wypisz_all(w->prawy);
            }
        }

    void wypisz(tnode *w)
        {
                cout<<w->nazwisko<<" "<<w->imie<<" "<<w->adres<<endl;
        }

    int cmp(tnode *p, tnode *n)
    {
        int ret;
        if((ret = p->nazwisko.compare(n->nazwisko)) != 0) return ret;
        if((ret = ret=p->imie.compare(n->imie) ) != 0) return ret;
        return p->adres.compare(n->adres);
    }

    void insert_bst(string naz, string im, string adr,long int nk,long int nd, long int ndp)
    {
        tnode *n = new  tnode(naz, im, adr, nk, nd, ndp);
        tnode *tmp=korzen;
        int v;
        wypisz(n);

        if(korzen==NULL)
        {
            korzen=n;
            korzen->p=NULL;
            korzen->lewy=NULL;
            korzen->prawy=NULL;
        }
        else
        {
        **    while(!tmp)**
            {
                if(cmp(tmp,n) == 0)
                {
                  cout<<"DUPLIKAT !!!"<<endl; return;
                }
                else if (cmp(tmp,n) > 0)
                tmp=tmp->prawy;
                else
                tmp=tmp->lewy;
            }

            n->p=tmp;
            if(cmp(tmp,n) == 0)
                {
                    cout<<"DUPLIKAT !!!"<<endl; return;
                }
                else if (cmp(tmp,n) > 0)
                tmp->prawy=n;
                else
                tmp->lewy=n;
        }
    }
};

int main()
{
    ksiazka ksioo;
    ksioo.insert_bst("a","b","d",45,45,45);
    cout << "dodano" << endl;
    getch();
    ksioo.insert_bst("a","c","d",45,45,45);
    cout << "dodano" << endl;
    getch();
    ksioo.insert_bst("a","a","c",45,45,45);
    cout << "dodano" << endl;
    getch();
    ksioo.wypisz_drzewo();
    getch();
    cout << "Hello world!" << endl;
    return 0;
} 
1

Zobacz dwa razy mniejsze a robi prawie to samo. Prawie polega na tym że nie ma wycieku pamięci.

bool insert_bst(string naz, string im, string adr,long int nk,long int nd, long int ndp)
  {
   tnode n(naz, im, adr, nk, nd, ndp);
   tnode *tmp=korzen,*parent=0;
   int v=0;
   // wypisz(&n); // to nie powinieneś robić tu
   while(tmp)
       {
        parent=tmp;
        v=cmp(tmp,&n);
        if(v<0) tmp=tmp->lewy; 
        else if(v>0) tmp=tmp->prawy;
        else return false; // cout<<"DUPLIKAT !!!"<<endl; // zrobisz w funkcji wywołującej
       }
   (parent?(v<0?parent->lewy:parent->prawy):korzen)=new tnode(n);
   return true;
  }
0

Zdaję sobie sprawę, że w chwili obecnej wychodzę na kogoś kto dostał palec, a zaczyna brać całą rękę, jednak to nie koniec problemów ;)

Wyszukiwanie elementu- wywołuję funkcję znajdź ze stringami których szukam na drzewie, ta z kolei wywołuje szukaj, zwracającą wskaźnik na węzeł. Tak wiem, miałem skorzystać z funkcji porównujące dwa węzły. Popełniłem takie coś:

 tnode *szukaj(tnode *tmp, string naz, string im, string adr)

    {

        int ret=0;

        if(tmp  == NULL || (naz.compare(tmp->nazwisko)==0 && im.compare(tmp->imie)==0 && adr.compare(tmp->adres) == 0) ) {return tmp;}

 

            if((ret = naz.compare(tmp->nazwisko)) != 0)

                {

                    if(ret<0) { szukaj(tmp->lewy,naz,im,adr); }

                    else { szukaj(tmp->prawy,naz,im,adr); }

                }

            if((ret = im.compare(tmp->imie) ) != 0)

                {

                    if(ret<0) { szukaj(tmp->lewy,naz,im,adr); }

                    else { szukaj(tmp->prawy,naz,im,adr); }

                }

            if((ret = adr.compare(tmp->adres)) != 0)

                {

                    if(ret<0) { szukaj(tmp->lewy,naz,im,adr); }

                    else { szukaj(tmp->prawy,naz,im,adr); }

                }

    }

 

    int znajdz(string naz, string im, string adr)

    {

        tnode *k=korzen;

        tnode *p = szukaj(k,naz,im,adr);

        wypisz(p);

    }
1

Masz super-mega talent do komplikowania sobie życia:

tnode *szukaj(tnode *tmp,const string &naz,const string &im,const string &adr)
   {
    node n(naz,im,adr,0,0,0);
    while(tmp)
       {
        v=cmp(tmp,&n);
        if(v<0) tmp=tmp->lewy; 
        else if(v>0) tmp=tmp->prawy;
        else return tmp;
       }
   return 0;
  }
  
void znajdz(string naz, string im, string adr)
  {
   tnode *p=szukaj(korzen,naz,im,adr);
   if(p) wypisz(p);
   else cout<<"nie znaleziono"<<endl;
  }
0

Teraz przerabiam to drzewo BST na RBT. Nie wiem czy w dobrym momencie koloruję węzeł? Zgodnie z założeniami drzewa RBT, każdy nowy węzeł powinienem pokolorować na czerwono.

   tnode* insert_bst(string naz, string im, string adr,long int nk,long int nd, long int ndp)
    {
        tnode n(naz, im, adr, nk, nd, ndp);
        tnode *tmp=korzen,*parent=0;
        int v=0;
        while(tmp)
        {
            parent=tmp;
            v=cmp(tmp,&n);
            if(v<0) tmp=tmp->lewy;
            else if(v>0) tmp=tmp->prawy;
            else return false; 
        }
        if(parent)
        {
            if(v<0) { parent->lewy = new tnode(n);  return parent->lewy; }
            else { parent->prawy = new tnode(n); return parent->prawy; }
        }
        else { korzen=new tnode(n);  return korzen; }
    }

    bool insert_RBT(string naz, string im, string adr,long int nk,long int nd, long int ndp)
    {
        tnode *y;
        tnode *x = insert_bst(naz,im,adr, nk, nd, ndp);
        ///Przywracanie równowagi
        while(korzen->lewy!=NULL && korzen->prawy!=NULL &&  x->p->kolor==RED)
        {
            if(x->p==x->p->p->lewy)
            {
                y=x->p->p->prawy;
                if(y->kolor==RED)
                {
                    x->p->kolor=BLACK;
                    y->kolor=BLACK;
                    x->p->p->kolor=RED;
                    x=x->p->p;
                }
                else
                {
                    if(x==x->p->prawy)
                    {
                        x=x->p;
                        Left_Rotate(x);
                    }
                    x->p->kolor=BLACK;
                    x->p->p->kolor=RED;
                    Right_Rotate(x->p->p);
                }
        }
      else
        {
          y=x->p->p->lewy;
          if(y->kolor==RED)
            {
              x->p->kolor=BLACK;
              y->kolor=BLACK;
              x->p->p->kolor=RED;
              x=x->p->p;
            }
          else
            {
              if(x==x->p->lewy)
                {
                  x=x->p;
                  Right_Rotate(x);
                }
              x->p->kolor=BLACK;
              x->p->p->kolor=RED;
              Left_Rotate(x->p->p);
            }
            }
        }
        korzen->kolor=BLACK;
    }

    void Left_Rotate(tnode *x)
    {
        tnode *y=x->prawy;
        x->prawy=y->lewy;
        if(y->lewy!=NULL) y->lewy->p=x;
        y->p=x->p;
        if(x->p==NULL) korzen=y;
            else
            if(x==x->p->lewy)x->p->lewy=y;
            else x->p->prawy=y;
        y->lewy=x;
        x->prawy=y;
    }

    void Right_Rotate(tnode *x)
    {
        tnode *y=x->lewy;
        x->lewy=y->prawy;
        if(y->prawy!=NULL) y->prawy->p=x;
        y->p=x->p;
        if(x->p==NULL) korzen=y;
        else
            if(x==x->p->prawy)x->p->prawy=y;
            else x->p->lewy=y;
        y->prawy=x;
        x->p=y;
    }

EDIT: Poprawione. Jednak nie wiem czemu nie wchodzi mi w pętlę while w funkcji insert_RBT()

0

A nie możesz tego wstawić do konstruktora tnode zamiast robić to w trzech miejscach?

0

Przekolorowanie ma nastąpić w przypdaku wystąpienia czerwonego ojca. Taka sytuacja powinna nastąpić w przypadku dodania 3 różnych węzłów. Wprowadzam przykładowe dane dla 4 węzłów, jednak przekolorowaniu ulega jedynie węzeł podany jako pierwszy.

0

Więc czas nauczyć się pisać zwęzły kod albo nauczyć się posługiwać się debuger'em.

0

Debugger prawdę Ci powie.

1 użytkowników online, w tym zalogowanych: 0, gości: 1