PDA

Visualizza la versione completa : [C++] Errori su ricerca in albero binario


pietrol83
30-03-2012, 11:25
ciao a tutti, sto creando la struttura albero binario di ricerca ma ho un problema col costruttore. in pratica l'albero binario di ricerca è una classe derivata di albero binario e implementa ulteriori metodi. in pratica mi viene segnalato un errore al costruttore dell'albero binario di ricerca. posto i codici:

nodoalberop.h


#ifndef nodoalberop_h
#define nodoalberop_h

#include<iostream>
#include<stdlib.h>

using namespace std;

template<class tipoelem>
class nodoalberop
{
public:
nodoalberop();

void setpadre(nodoalberop *);
void setfigliosx(nodoalberop *);
void setfigliodx(nodoalberop *);
void setetichetta(tipoelem);

nodoalberop *getpadre();
nodoalberop *getfigliosx();
nodoalberop *getfigliodx();
tipoelem getetichetta();

nodoalberop operator=(nodoalberop);

int livello;
private:
nodoalberop *padre;
nodoalberop *figliosx;
nodoalberop *figliodx;
tipoelem etichetta;
};

#endif

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop()
{
padre = NULL;
figliosx = NULL;
figliodx = NULL;
etichetta = 0;
livello = -1;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setpadre(nodoalberop<tipoelem> *p)
{
padre = p;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setfigliosx(nodoalberop<tipoelem> *fsx)
{
figliosx = fsx;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setfigliodx(nodoalberop<tipoelem> *fdx)
{
figliodx = fdx;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setetichetta(tipoelem elem)
{
etichetta = elem;
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getpadre()
{
return(padre);
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getfigliosx()
{
return(figliosx);
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getfigliodx()
{
return(figliodx);
}

template<class tipoelem>
tipoelem nodoalberop<tipoelem>::getetichetta()
{
return(etichetta);
}

template<class tipoelem>
nodoalberop<tipoelem> nodoalberop<tipoelem>::operator=(nodoalberop<tipoelem> node)
{
this->setpadre(node.getpadre());
this->setfigliosx(node.getfigliosx());
this->setfigliodx(node.getfigliodx());
this->setetichetta(node.getetichetta());
}

alberobinp.h


#ifndef alberobinp_h
#define alberobinp_h

#include "nodoalberop.h"
#include<assert.h>
#include<iostream>
#include<stdlib.h>

using namespace std;

template<class tipoelem>
class alberobinp
{
public:
typedef nodoalberop<tipoelem> *nodo;
alberobinp();

void creabinalbero();
bool binalberovuoto();
nodo binradice();
nodo binpadre(nodo);
nodo figliosx(nodo);
nodo figliodx(nodo);
bool sxvuoto(nodo);
bool dxvuoto(nodo);
tipoelem legginodo(nodo);
void scrivinodo(nodo, tipoelem);
void insbinradice(nodo);
void insfigliosx(nodo);
void insfigliodx(nodo);
void cancsottoalbero(nodo);
protected:
nodo radice;
};

#endif

template<class tipoelem>
alberobinp<tipoelem>::alberobinp()
{
this->creabinalbero();
}

template<class tipoelem>
void alberobinp<tipoelem>::creabinalbero()
{
radice = NULL;
}

template<class tipoelem>
bool alberobinp<tipoelem>::binalberovuoto()
{
return(radice == NULL);
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::binradice()
{
assert(!this->binalberovuoto());
return(radice);
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::binpadre(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && (node != radice));
return(node->getpadre());
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::figliosx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && !this->sxvuoto(node));
return(node->getfigliosx());
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::figliodx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && !this->dxvuoto(node));
return(node->getfigliodx());
}

template<class tipoelem>
bool alberobinp<tipoelem>::sxvuoto(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto());
return(node->getfigliosx() == NULL);
}

template<class tipoelem>
bool alberobinp<tipoelem>::dxvuoto(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto());
return(node->getfigliodx() == NULL);
}

template<class tipoelem>
tipoelem alberobinp<tipoelem>::legginodo(typename alberobinp<tipoelem>::nodo node)
{
return(node->getetichetta());
}

template<class tipoelem>
void alberobinp<tipoelem>::scrivinodo(typename alberobinp<tipoelem>::nodo node, tipoelem elem)
{
node->setetichetta(elem);
}

template<class tipoelem>
void alberobinp<tipoelem>::insbinradice(typename alberobinp<tipoelem>::nodo node)
{
assert(this->binalberovuoto());
radice = node;
}

template<class tipoelem>
void alberobinp<tipoelem>::insfigliosx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && this->sxvuoto(node));
nodo temp = new nodoalberop<tipoelem>;
node->setfigliosx(temp);
temp->setpadre(node);
}

template<class tipoelem>
void alberobinp<tipoelem>::insfigliodx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && this->dxvuoto(node));
nodo temp = new nodoalberop<tipoelem>;
node->setfigliodx(temp);
temp->setpadre(node);
}

template<class tipoelem>
void alberobinp<tipoelem>::cancsottoalbero(alberobinp<tipoelem>::nodo node)
{
if(node->getfigliosx() != NULL)
this->cancsottoalbero(node->getfigliosx());
if(node->getfigliodx() != NULL)
this->cancsottoalbero(node->getfigliodx());
if(node == this->binradice())
radice = NULL;
delete node;
}



segue--->

pietrol83
30-03-2012, 11:28
bstreep.h


#ifndef bstreep_h
#define bstreep_h

#include "alberobinp.h"

#include<iostream>
#include<stdlib.h>
#include<assert.h>

template<class tipoelem>
struct Tipoelem
{
tipoelem valore;
int chiave;
};

template<class tipoelem>
class bstreep : public alberobinp<struct Tipoelem>
{
public:
typedef struct Tipoelem<tipoelem> Tipoelem;
typedef nodoalberop<tipoelem> *nodo;

bstreep();

nodo min();
bool appartiene(nodo);
void inserisci(nodo);
void cancella(nodo);
};

#endif

template<class tipoelem>
bstreep<tipoelem>::bstreep() : alberobinp<tipoelem>::alberobinp()
{}

template<class tipoelem>
typename bstreep<tipoelem>::nodo bstreep<tipoelem>::min()
{
nodo min = this->radice();
while(!this->sxvuoto(min))
min = this->figliosx(min);

return min;
}

template<class tipoelem>
bool bstreep<tipoelem>::appartiene(typename bstreep<tipoelem>::nodo node)
{
bool trovato = false;

nodo tmp = this->radice();
while(!trovato && !(this->sxvuoto(tmp) && this->dxvuoto(tmp)))
{
if(this->legginodo(tmp).valore == node->getelem().valore)
trovato = true;
else
{
if(this->legginodo(tmp).chiave < node->getelem().chiave)
tmp = this->figliodx(tmp);
else
tmp = this->figliosx(tmp);
}
}

return trovato;
}

template<class tipoelem>
void bstreep<tipoelem>::inserisci(typename bstreep<tipoelem>::nodo node)
{
nodo tmp = this->radice();
bool trovato = false;

if(!this->appartiene(node))
{
while(!trovato)
{
if(node->getelem().chiave < this->legginodo(tmp).chiave)
{
if(this->sxvuoto(tmp))
{
this->insfigliosx(tmp);
trovato = true;
}
else
tmp = this->figliosx(tmp);
}
else
{
if(this->dxvuoto(tmp))
{
this->insfigliodx(tmp);
trovato = true;
}
else
tmp = this->figliodx(tmp);
}
}
}
}

template<class tipoelem>
void bstreep<tipoelem>::cancella(typename bstreep<tipoelem>::nodo node)
{
if(this->sxvuoto(node) && this->dxvuoto(node))
this->cancsottoalbero(node);
else
{
if(!this->sxvuoto(node) && !this->dxvuoto(node))
{
nodo tmp = this->min();
this->cancella(this->min());
node->getelem().valore = tmp->getelem().valore;
node->getelem().chiave = tmp->getelem().chiave;
}
else
{
if(this->sxvuoto(node) && !this->dxvuoto(node))
{
nodo tmp = this->figliodx(node);
node->setfigliodx(NULL);
this->cancsottoalbero(node);
if(node == this->figliosx(this->padre(node)))
this->insfigliosx(tmp);
else
this->insfigliodx(tmp);
}
else
{
nodo tmp = this->figliosx(node);
node->setfigliosx(NULL);
this->cancsottoalbero(node);
if(node == this->figliosx(this->padre(node)))
this->insfigliosx(tmp);
else
this->insfigliodx(tmp);
}
}
}
}

testbstreep.cpp


#include "bstreep.h"

#include<iostream>
#include<stdlib.h>

using namespace std;

int main()
{
bstreep<int> T;
cout << "bstreevuoto() = " << T.binalberovuoto() << "\n\n";

system("pause");
return 0;
}

la riga che mi dà problemi è quella in rosso e l'errore segnalato è il seguente:

36 C:\Dev-Cpp\Strutture\Bstree\bstreep.h type `class alberobinp<int>' is not a direct base of `bstreep<int>'


cosa non va??

ramy89
30-03-2012, 11:55
Io non ho capito quali erano le tue intenzioni, se volevi semplicemente dichiarare un metodo di bstreep, basterebbe:



template <class tipoelem>
bstreep<tipoelem>::bstreep() {...}

pietrol83
30-03-2012, 11:59
Originariamente inviato da ramy89
Io non ho capito quali erano le tue intenzioni, se volevi semplicemente dichiarare un metodo di bstreep, basterebbe:



template <class tipoelem>
bstreep<tipoelem>::bstreep() {...}


io devo implementare un albero binario di ricerca. poichè l'albero binario ce l'ho già, l'ho implementato come classe derivata della classe alberobinp e ho aggiunto nuovi metido che sono quelli di bstreep. in pratica il costruttore di bstreep deve chiamare il costruttore di alberobinp e mi dà errore.

ramy89
30-03-2012, 12:15
Originariamente inviato da pietrol83
io devo implementare un albero binario di ricerca. poichè l'albero binario ce l'ho già, l'ho implementato come classe derivata della classe alberobinp e ho aggiunto nuovi metido che sono quelli di bstreep. in pratica il costruttore di bstreep deve chiamare il costruttore di alberobinp e mi dà errore.

Non hai bisogno di fare nulla del genere.Il costruttore della superclasse è chiamato in maniera automatica.
La sintassi corretta per il costruttore è quella che vedi nel mio post precedente.

pietrol83
03-04-2012, 11:53
ciao a tutti, ho creato un albero binario di ricerca e tra i metodi da testare ce n'è uno che fa una cosa strana. in pratica nell'inserimento dei nodi, il primo nodo da inserire è la radice. nel fare ciò il metodo ha un'if per controllare se l'albero è vuoto o meno in modo da decidere se inserire la radice o un figlio; inizialmente il controllo dell'if è vero ma dopo aver eseguito il blocco "then" esegue anche un'istruzione del blocco "else". ho controllato anche le parentesi e sono bilanciate, quindi non dovrebbero esserci problemi. come mai fa questa cosa??? posto i codici.

nodoalberop.h


#ifndef nodoalberop_h
#define nodoalberop_h

#include<iostream>
#include<stdlib.h>

using namespace std;

template<class tipoelem>
class nodoalberop
{
public:
nodoalberop();

void setpadre(nodoalberop *);
void setfigliosx(nodoalberop *);
void setfigliodx(nodoalberop *);
void setetichetta(tipoelem);
void setchiave(int);

nodoalberop *getpadre();
nodoalberop *getfigliosx();
nodoalberop *getfigliodx();
tipoelem getetichetta();
int getchiave();

nodoalberop operator=(nodoalberop);

int livello;
private:
nodoalberop *padre;
nodoalberop *figliosx;
nodoalberop *figliodx;
tipoelem etichetta;
int chiave;
};

#endif

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop()
{
padre = NULL;
figliosx = NULL;
figliodx = NULL;
livello = -1;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setpadre(nodoalberop<tipoelem> *p)
{
padre = p;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setfigliosx(nodoalberop<tipoelem> *fsx)
{
figliosx = fsx;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setfigliodx(nodoalberop<tipoelem> *fdx)
{
figliodx = fdx;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setetichetta(tipoelem elem)
{
etichetta = elem;
}

template<class tipoelem>
void nodoalberop<tipoelem>::setchiave(int key)
{
chiave = key;
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getpadre()
{
return(padre);
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getfigliosx()
{
return(figliosx);
}

template<class tipoelem>
nodoalberop<tipoelem>::nodoalberop<tipoelem> *nodoalberop<tipoelem>::getfigliodx()
{
return(figliodx);
}

template<class tipoelem>
tipoelem nodoalberop<tipoelem>::getetichetta()
{
return(etichetta);
}

template<class tipoelem>
int nodoalberop<tipoelem>::getchiave()
{
return chiave;
}

template<class tipoelem>
nodoalberop<tipoelem> nodoalberop<tipoelem>::operator=(nodoalberop<tipoelem> node)
{
this->setpadre(node.getpadre());
this->setfigliosx(node.getfigliosx());
this->setfigliodx(node.getfigliodx());
this->setetichetta(node.getetichetta());
}

alberobinp.h


#ifndef alberobinp_h
#define alberobinp_h

#include "nodoalberop.h"
#include<assert.h>
#include<iostream>
#include<stdlib.h>

using namespace std;

template<class tipoelem>
class alberobinp
{
public:
typedef nodoalberop<tipoelem> *nodo;
alberobinp();

void creabinalbero();
bool binalberovuoto();
nodo binradice();
nodo binpadre(nodo);
nodo figliosx(nodo);
nodo figliodx(nodo);
bool sxvuoto(nodo);
bool dxvuoto(nodo);
tipoelem legginodo(nodo);
void scrivinodo(nodo, tipoelem);
void insbinradice(nodo);
void insfigliosx(nodo);
void insfigliodx(nodo);
void cancsottoalbero(nodo);
protected:
nodo radice;
};

#endif

template<class tipoelem>
alberobinp<tipoelem>::alberobinp()
{
this->creabinalbero();
}

template<class tipoelem>
void alberobinp<tipoelem>::creabinalbero()
{
radice = NULL;
}

template<class tipoelem>
bool alberobinp<tipoelem>::binalberovuoto()
{
return(radice == NULL);
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::binradice()
{
assert(!this->binalberovuoto());
return(radice);
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::binpadre(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && (node != radice));
return(node->getpadre());
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::figliosx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto());
return(node->getfigliosx());
}

template<class tipoelem>
typename alberobinp<tipoelem>::nodo alberobinp<tipoelem>::figliodx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto());
return(node->getfigliodx());
}

template<class tipoelem>
bool alberobinp<tipoelem>::sxvuoto(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto());
return(node->getfigliosx() == NULL);
}

template<class tipoelem>
bool alberobinp<tipoelem>::dxvuoto(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto());
return(node->getfigliodx() == NULL);
}

template<class tipoelem>
tipoelem alberobinp<tipoelem>::legginodo(typename alberobinp<tipoelem>::nodo node)
{
return(node->getetichetta());
}

template<class tipoelem>
void alberobinp<tipoelem>::scrivinodo(typename alberobinp<tipoelem>::nodo node, tipoelem elem)
{
node->setetichetta(elem);
}

template<class tipoelem>
void alberobinp<tipoelem>::insbinradice(typename alberobinp<tipoelem>::nodo node)
{
assert(this->binalberovuoto());
radice = node;
}

template<class tipoelem>
void alberobinp<tipoelem>::insfigliosx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && this->sxvuoto(node));
nodo temp = new nodoalberop<tipoelem>;
node->setfigliosx(temp);
temp->setpadre(node);
}

template<class tipoelem>
void alberobinp<tipoelem>::insfigliodx(typename alberobinp<tipoelem>::nodo node)
{
assert(!this->binalberovuoto() && this->dxvuoto(node));
nodo temp = new nodoalberop<tipoelem>;
node->setfigliodx(temp);
temp->setpadre(node);
}

template<class tipoelem>
void alberobinp<tipoelem>::cancsottoalbero(alberobinp<tipoelem>::nodo node)
{
if(node->getfigliosx() != NULL)
this->cancsottoalbero(node->getfigliosx());
if(node->getfigliodx() != NULL)
this->cancsottoalbero(node->getfigliodx());
if(node == this->binradice())
radice = NULL;
delete node;
}

bstreep.h


#ifndef bstreep_h
#define bstreep_h

#include "alberobinp.h"

#include<iostream>
#include<stdlib.h>
#include<assert.h>

template<class tipoelem>
class bstreep : public alberobinp<tipoelem>
{
public:
typedef nodoalberop<tipoelem> *nodo;

bstreep();

tipoelem min();
bool appartiene(nodo);
void inserisci(nodo);
void cancella(nodo);
};

#endif

template<class tipoelem>
bstreep<tipoelem>::bstreep()
{}

template<class tipoelem>
tipoelem bstreep<tipoelem>::min()
{
nodo min = this->binradice();
while(!this->sxvuoto(min))
min = this->figliosx(min);

return min->getetichetta();
}

template<class tipoelem>
bool bstreep<tipoelem>::appartiene(typename bstreep<tipoelem>::nodo node)
{
bool trovato = false;

nodo tmp = this->binradice();
while(!trovato && !(this->sxvuoto(tmp) && this->dxvuoto(tmp)))
{
if(tmp->getetichetta() == node->getetichetta())
trovato = true;
else
{
if(tmp->getchiave()< node->getchiave())
tmp = this->figliodx(tmp);
else
tmp = this->figliosx(tmp);
}
}

return trovato;
}

template<class tipoelem>
void bstreep<tipoelem>::inserisci(typename bstreep<tipoelem>::nodo node)
{
if(this->binalberovuoto())
this->insbinradice(node);
else
{
typename alberobinp<tipoelem>::nodo tmp = this->binradice();
bool trovato = false;

if(!this->appartiene(node))
{
while(!trovato)
{
if(node->getchiave() < tmp->getchiave())
{
if(this->sxvuoto(tmp))
{
this->insfigliosx(tmp);
trovato = true;
}
else
tmp = this->figliosx(tmp);
}
else
{
if(this->dxvuoto(tmp))
{
this->insfigliodx(tmp);
trovato = true;
}
else
tmp = this->figliodx(tmp);
}
}
}
}
}

template<class tipoelem>
void bstreep<tipoelem>::cancella(typename bstreep<tipoelem>::nodo node)
{
if(this->sxvuoto(node) && this->dxvuoto(node))
this->cancsottoalbero(node);
else
{
if(!this->sxvuoto(node) && !this->dxvuoto(node))
{
nodo tmp = this->min();
this->cancella(this->min());
node->getetichetta() = tmp->getetichetta();
node->getchiave() = tmp->getchiave();
}
else
{
if(this->sxvuoto(node) && !this->dxvuoto(node))
{
nodo tmp = this->figliodx(node);
node->setfigliodx(NULL);
this->cancsottoalbero(node);
if(node == this->figliosx(this->padre(node)))
this->insfigliosx(tmp);
else
this->insfigliodx(tmp);
}
else
{
nodo tmp = this->figliosx(node);
node->setfigliosx(NULL);
this->cancsottoalbero(node);
if(node == this->figliosx(this->padre(node)))
this->insfigliosx(tmp);
else
this->insfigliodx(tmp);
}
}
}
}

testbstreep.cpp


#include "bstreep.h"

#include<iostream>
#include<stdlib.h>

using namespace std;

int main()
{
bstreep<int> T;
cout << "bstreevuoto() = " << T.binalberovuoto() << "\n\n";


int value = 0;
int key = 0;
while(value != -1)
{
cin >> value;
cin >> key;
cout << "\n";
alberobinp<int>::nodo n = new nodoalberop<int>;
n->setetichetta(value);
n->setchiave(key);
T.inserisci(n);
cout << T.binalberovuoto() << "\n";
cout << T.sxvuoto(T.binradice()) << "\n";
cout << T.dxvuoto(T.binradice()) << "\n\n";
}
cout << "min = " << T.min() << "\n\n";

system("pause");
return 0;
}

le istruzioni che non vanno bene sono quelle in rosso.
facendo il debugging, subito dopo l'esecuzione del blocco "if"
ho notato che il cursore va sulla parentesi di fine del blocco else che si trova nel ciclo while (parentesi rossa), quando nell'inserimento della radice il ciclo while non deve essere incontrato. perchè?

alka
03-04-2012, 12:03
Originariamente inviato da pietrol83
ciao a tutti, ho creato un albero binario di ricerca e tra i metodi da testare ce n'è uno che fa una cosa strana.

Inutile aprire una nuova discussione, visto che l'argomento generale era già trattato in un'altra aperta precedentemente.

Come suggerimento generale, invece, ti suggerirei di ridurre la quantità di codice che posti, o di focalizzare il problema affrontandone uno alla volta, o suddividendolo in sottoproblemi, poiché difficilmente gli utenti prenderanno tutto il sorgente che hai scritto per provarlo, e per come poni le questioni è l'unico modo che possono usare per darti una mano.

pietrol83
03-04-2012, 12:06
sei il primo che mi chiede di essere sintetico. in precedenza lo sono stato e mi hanno chiesto di postare tutti i codici necessari. ho aperto un'altra discussione perchè rispetto al codice della discussione precedente ho fatto alcune modifiche e poi anche se il codice è simile il problema è diverso e in punti diversi.

alka
03-04-2012, 12:19
Originariamente inviato da pietrol83
sei il primo che mi chiede di essere sintetico.
Non ti ho chiesto di sintetizzare, che vuol dire riassumere in meno parole i contenuti, ma di riportare solo quelli di interesse.


Originariamente inviato da pietrol83
in precedenza lo sono stato e mi hanno chiesto di postare tutti i codici necessari.

Questo perché il problema che poni riguarda una parte di codice che non è isolata ma che ha dipendenze e influenze inferte da tutto il resto del programma, e quindi sei costretto a fare in questo modo, anche se a mio avviso 1) complica la vita anche a te, 2) rende difficile rispondere, poiché non si tratta di dare un suggerimento ma di prendere tutto il codice, compilarlo e andare a debuggare al posto tuo, 3) non è possibile affrontare l'errore in modo generico e valido per altre situazioni analoghe, quindi diventa un'assistenza tecnica mirata e non una discussione con concetti che possono servire ad altri.


Originariamente inviato da pietrol83
ho aperto un'altra discussione perchè rispetto al codice della discussione precedente ho fatto alcune modifiche e poi anche se il codice è simile il problema è diverso e in punti diversi.
Il codice che hai scritto può produrre tanti errori: non possiamo aprire una discussione sulla ricerca in un albero binario per ogni più piccolo e minuscolo errore che riscontri, per cui affrontiamoli almeno in una discussione unica.

pietrol83
03-04-2012, 12:24
Originariamente inviato da alka
1) complica la vita anche a te,

lo so che complica la vita anche a me. questo è il compito dei professori!! :-)
non posso fare dei sottoproblemi perchè mi si richiede che i metodi siano solo ed esclusivamente quelli che ho scritto nelle specifiche.

Loading