[JAVA] Leggo una stringa, costruisco un albero

[noiseimpera]

Ciao a tutti. Vi presento il mio problema. Devo scrivere una funzione che data in ingresso una stringa mi costruisca un albero. In linea teorica non sarebbe granchè difficile ma nella pratica sto avendo molti problemi. Dunque, ho una stringa del tipo:

(a•((b•(c• NIL))•(d•((e•(f•(g• NIL)))•NIL))))

che mi deve produrre l'albero allegato.

In particolare:
- alla parentesi aperta corrisponde la creazione di un nuovo nodo;
- ai caratteri/stringhe corrisponde una foglia;
- al pallino corrisponde la concatenazione con del sottoalbero sinistro con quello destro.

Se vi può far comodo posso postare il codice che ho scritto.
Spero di esser stato chiaro e che qualcuno di voi riesca ad aiutarmi nella risoluzione dell'inghippo.

[LeleFT]

Originariamente inviato da noiseimpera
Se vi può far comodo posso postare il codice che ho scritto.

Non è questione di comodo, ma di poter capire quali difficoltà incontri e dove.
Se non posti il codice, come facciamo ad aiutarti? Tieni presente che qui non è ammessa la richiesta di sviluppo totale del codice...

PS: Java ha un forum dedicato. Sposto la discussione.


Ciao.

[noiseimpera]

Premetto che in ingresso della mia readSE ho questo oggetto LispTokenizer che mi fa il parsing della stringa e mi restituisce elemento per elemento un intero che identifica appunto l'elemento corrente. Datela per buona perchè la classe LispTokenizer mi è stata fornita, è verificata e funziona perfettamente quindi il problema sta nel mio codice.

Altra premessa, la mia struttura Tree è così fatta:

   private String inf;  
   private Tree sx;  
   private Tree dx;  
   private boolean punto = false;  
   private boolean closed= false;

Il codice è il seguente:

protected static Tree readSE(LispTokenizer lt) {  
       Tree letto = null;  
       int select=lt.next();  
       if(select!=LispTokenizer.EOF){  
       switch(select){  
         
       case LispTokenizer.OPEN:{  
           Tree sx=readSE(lt);  
           letto=new Tree(sx,readSE(lt));  
           if(letto.dx!=null)letto.punto=letto.dx.punto;  
           return letto;  
       }  
     
       case LispTokenizer.CLOSED:{ ????  
           letto= new Tree(null);  
           letto.closed=true;  
             
           return letto;  
       }  
         
       case LispTokenizer.ATOM:{  
           return new Tree(lt.getAtom());  
       }  
 
       case LispTokenizer.BLANK:{  
           return new Tree(readSE(lt),readSE(lt));  
             
       }  
         
       case LispTokenizer.DOT:{  
           int elem =lt.next();  
           if(elem == LispTokenizer.OPEN){  
               letto = new Tree(readSE(lt),readSE(lt));  
           }  
           else if(elem==LispTokenizer.ATOM)  
               letto=new Tree(new Tree(lt.getAtom()),readSE(lt));  
                         
           if(letto.dx!=null)  
               letto.punto=letto.sx.punto=letto.dx.punto=true;  
           else  
               letto.punto=letto.sx.punto=true;      
           return letto;  
       }  
                 
       default:{return readSE(lt);}  
       }}  
       return null;  
   }

dove
EOF, indica che la stringa è terminata;
OPEN, parentesi aperta
CLOSE, parentesi chiusa
BLANK, spazio
DOT, pallino/punto di concatenazione
ATOM, carattere o sottostringa da scrivere nella generica foglia.

con particolare attenzione nel caso del closed dato che sicuramente lì ci andrà qualcos'altro.

[desa]

Ho dato un'occhiata al codice... ma non mi è chiaro a cosa servono gli attributi "inf" (che non usi mai), "punto" e "closed" della classe Tree

[noiseimpera]

inf è l'informazione che andrà ad essere scritta nella foglia; praticamente il campo key di un albero. closed è un flag che mi indica quando il nodo "chiude una parentesi" e punto un altro flag che mi serve per sapere quando devo concatenare. questi flag e l'inf poi li utilizzo in un'altra funzione che invece leggendo l'albero mi stampa la stringa.
grazie per avermi risposto

[desa]

Riguardo a "inf" lo immaginavo, ma poichè nel codice non lo vai mai a settare immagino che venga fatto dal costruttore di Tree quando trovi un ATOM.
Non vedo di buon occhio "closed" e "punto" come attributi di Tree: sono variabili temporanee per la costruzione di un albero, progettualmente non è bello considerarle variabili d'istanza. Oltretutto attento, perchè tu cerchi di accederci direttamente (e anche questo non è bello, dovresti utilizzare dei metodi getter e setter) come in

letto.punto=letto.sx.punto=letto.dx.punto=true;

ma questo non può funzionare perchè tutti gli attributi sono definiti "private". Prova a lasciare così e vedrai come te le suona il compilatore...

In ogni caso, non l'hai detto: che tipo di problemi riscontri?

[noiseimpera]

dopo aver costruito l'albero quando lo vado a stampare(con una funzione printTree) mi produce questo risultato:

(LABEL FF (LAMBDA (X) (COND ((ATOM X) X) ((QUOTE T) (FF (CAR X)))

piuttosto che questo

(LABEL FF (LAMBDA (X) (COND ((ATOM X) X) ((QUOTE T) (FF (CAR X))))))

in sostanza non mi stampa le tre parentesi chiuse finale e dato che il test riparte da questa stringa prodotta per creare un nuovo albero, l'albero che mi viene costruito è sballato e quando vado ad applicare i metodi sullo stesso mi da NullPointerException.

ps. se considero che la funzione di stampa è corretta il problema dovrebbe risiedere in questa funzione.

[noiseimpera]

posto, per correttezza di informazioni, anche la mia funzione di stampa

public String toString(){  
       return printTree(this,true);  
}  
 
private String printTree(Tree t, boolean r){  
       String s="";  
       if(t!=null){  
           if(t.isAtom()){  
               if(t.closed){  
                   if(r)s = s+ '(';  
                   s= s+ ')';  
               }  
               else  
                   s=s+t.inf;  
               }  
           else{  
               if(t.sx.isAtom() && t.dx.isAtom() && !t.dx.closed){  
                   s=s+"("+t.sx.inf+'.'+t.dx.inf+")";  
               return s;  
               }  
               else if(r)s=s+'(';  
               else{  
                   if(t.punto){  
                       if(t.dx.closed)s= s+'.';  
                       else s= s+".(";  
                   }      
                   else{s=s+' ';}  
               }  
               s=s+ printTree(t.sx, true)+ printTree(t.dx, false);  
           }  
       }  
       return s;  
   }  
}

magari non è corretta come penso e si evita di perdere tempo. comunque al di là delle scorrettezze dite che quel metodo readSE funzioni?