Lista concatenata in Java

[D4rkAng3l]

Ciao,
posto parte dell'esercitazione trovata sul sito della mia proff circa le liste concatenate in Java. Tale esercitazione prevede di implementare una lista concatenata tramite l'uso di 2 classi: una che rappresenta oggetti nodo ed una che rappresenta la lista vera e propria e che usa la classe nodo.

Ho qualche dubbio sulla correttezza del mio materiale didattico e spero che possiate illuminarmi

La classe NodoInt è:

/** Classe che rappresenta e gestisce singoli nodi di una lista concatenata; Gli oggetti sono MUTABILI */

public class NodoInt{
	private int valore;				// Valore di tipo intero contenuto nel nodo (è il campo informazione del nodo)
	private NodoInt successivo;		// Contiene il riferimento ad un oggetto di tipo NodoInt che contiene l'elemento successivo
	
	/** COSTRUTTORE :crea un nodo il cui valore è quello del parametro e che non è concatenato ad alcun altro nodo */

	public NodoInt(int n){
		valore = n;						// Nel campo valore del nuovo nodo creato viene messo il valore del parametro
		successivo = null;				// Nel campo successivo viene messo il valore null: il nuovo nodo non punta a niente
	}
	
	/** Accede in lettura al valore del nodo oggetto ricevente */
	
	public int getValore(){
		return valore;				// Ritorna il valore contenuto nel nodo oggetto ricevente
	}
	
	/** Accede in lettura al riferimento al nodo che segue il nodo oggetto ricevente. *NB: Espone l'oggetto ricevente a
	    possibili effetti collaterali */
	
	public NodoInt getSuccessivo(){
		return successivo;
	}
	
	/** Configura l'oggetto ricevente in modo tale da avere il parametro come successore. *NB: Modifica l'oggetto ricevente */
	
	public void setSuccessivo(NodoInt altro){
		this.successivo = altro;
	}
	
	/** Fornisce una rappresentazione in forma di stringa dell'oggetto ricevente */
	
	public String toString(){
		String s = " " + valore + "";
		
		if(successivo != null) s+= "->":
		
		return s;
	}
}

La casse ListaDiInteri (per ora ho messo solo i 2 metodi che a mio avviso potrebbeo essere sbagliati) è:

/** Classe che rappresenta e gestisce una lista concatenata di nodi che contengono valori interi; Gli oggetti sono MUTABILI */

public class ListaDiInteri{
	
	private NodoInt N;			// Primo nodo della lista
	
	/** COSTRUTTORE: Crea un nuovo oggetto ListaDiInteri che inizialmente è una lista vuota*/
	
	public ListaDiInteri(){
		N = null;				// Il primo nodo è inizialmente un elemento nullo
	}
	
	/** Se il nodo parametro non ha successori lo aggiunge in testa alla lista alla lista, altrimenti crea un nodo il cui
	    valore coincide con quello del parametro e lo aggiunge in testa alla lista. *NB: Modifica l'oggetto ricevente */
	  
	public void aggiungiInTesta(NodoInt altro){
		NodoInt T = new NodoInt(altro.getValore());	// Costruisce un nuovo nodo T avente il valore di altro
		T.setSuccessivo(N);			// Il nodo T è diventatola la nuova testa della lista e punta alla vecchia testa
		N = altro;
	}
	
	/** Crea un nodo il cui valore coincide con il parametro di tipo intero e lo aggiunge in testa alla lista.
	    *NB: Modifica l'oggetto ricevente */
	  
	public void aggiungiInTesta(int n){
		NodoInt T = new NodoInt(n);
		T.setSuccessivo(N);
		N = altro;
	}
}

Secondo me i due metodi aggiungiInTesta che appunto aggiungono in testa un nuovo nodo sono concettualmente sbagliati perchè:

1) Il primo dei due metodi prende come parametro un oggetto NodoInt di nome altro (per semplicità consideriamolo senza successori) e modifica l'oggetto ricevente (una lista) mettendolo in testa alla lista.

Per fare ciò crea un nodo T copia dell'oggetto altro ricevuto (copia il valore di altro nel campo valore del nuovo nodo T).
Poi modifica il campo successivo del nodo T appena creato e lo fà puntare alla lista N (praticamente lo fà puntare alla vecchia testa della lista N). Ok...fino quì tutto bene credo...la cosa che mi turba è l'istruzione:
N = altro;
Perchè?!?! altro era il parametro che era stato copiato in T...non dovrebbe essere:
N = T; ?!?!
Cioè ho creato un nuovo nodo T che contiene la copia di altro, ho fatto puntare T alla vecchia testa della lista N ed ora devo modificare N e dire che la nuova testa è T...

Anche nel secondo metodo mi impiccio su questa cosa...ha sbagliato la poff o sono io che non vedo qualcosa?

Grazie
Andrea

[dongiulio]

A occhio penso tu abbia ragione, in quella implementazione dovrebbe essere N = T.

La cosa brutta in quel codice è comunque il fatto che si crei un nuovo NodoInt quando non c'è n'è alcun bisogno, si poteva benissimo usare l'oggetto passato al metodo, senza duplicarlo.

D'altro canto dopo averlo aggiunto alla lista ci si aspetta di aver aggiunto proprio quello, non un suo gemellino.

il metodo:
public void aggiungiInTesta(int n){
NodoInt T = new NodoInt(n);
T.setSuccessivo(N);
N = altro;
}

dovrebbe dare un errore di compilazione in quanto fa riferimento ad "altro" che non è stato passato come parametro e non è nello scope.

Riguardo la correttezza ho due appunti da fare, sembra che la tua professoressa ignori le regole sui JavaDoc, quando si usa /** si sta inserendo un JavaDoc in cui bisogna scrivere le cose in un certo modo, ed è diverso da /* che è un semplice commento.

Un'altra cosa importante è il numero di colonne. E' buona pratica formattare ogni programma Java in modo che non superi le 80 colonne, questo facilita di molto la lettura del codice.

un'altra cosa p il nome delle variabili, è sconsigliato usare variabili che iniziano con la lettera maiuscola, la lettera maiuscola iniziale secondo le convenzioni è riservata per i nomi delle classi.

A prima vista il resto sembra migliorabile ma a posto.

[D4rkAng3l]

Originariamente inviato da dongiulio
A occhio penso tu abbia ragione, in quella implementazione dovrebbe essere N = T.

La cosa brutta in quel codice è comunque il fatto che si crei un nuovo NodoInt quando non c'è n'è alcun bisogno, si poteva benissimo usare l'oggetto passato al metodo, senza duplicarlo.

D'altro canto dopo averlo aggiunto alla lista ci si aspetta di aver aggiunto proprio quello, non un suo gemellino.

il metodo:
public void aggiungiInTesta(int n){
NodoInt T = new NodoInt(n);
T.setSuccessivo(N);
N = altro;
}

dovrebbe dare un errore di compilazione in quanto fa riferimento ad "altro" che non è stato passato come parametro e non è nello scope.

Riguardo la correttezza ho due appunti da fare, sembra che la tua professoressa ignori le regole sui JavaDoc, quando si usa /** si sta inserendo un JavaDoc in cui bisogna scrivere le cose in un certo modo, ed è diverso da /* che è un semplice commento.

Un'altra cosa importante è il numero di colonne. E' buona pratica formattare ogni programma Java in modo che non superi le 80 colonne, questo facilita di molto la lettura del codice.

un'altra cosa p il nome delle variabili, è sconsigliato usare variabili che iniziano con la lettera maiuscola, la lettera maiuscola iniziale secondo le convenzioni è riservata per i nomi delle classi.

A prima vista il resto sembra migliorabile ma a posto.

Ti ringrazio...si di solito le dispense della proff sono molto precise...e fanno un corretto uso di javadoc...questa invece è un po' incasinata...avrà avuto fretta....

Ciao e grazie
Andrea