Pagina 1 di 3 1 2 3 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 26
  1. #1

    Esercizio complesso sulle liste

    codice:
    Si realizzino due classi che implementino le interfacce Node e LinkedList (descritte
    nella pagina seguente) e che siano in grado gestire un insieme attraverso l'uso di
    una lista linkata semplice.
    Si scriva in seguito un programma Java che, utilizzando la nuova classe per la
    gestione di un insieme, prenda in input un file contenente una sequenza di terne,
    del tipo (a,b,c), e scriva in un file di output la medesima sequenza in cui le terne
    sono state riordinate, in senso non decrescente, in base al valore degli elementi
    contenuti nelle terne (ordinare sul primo valore; in caso di valore uguale ordinare sul
    secondo valore; in caso di uguaglianza dei primi due valori ordinare sul terzo
    valore).
    Input
    Il file di input contiene una sequenza di terne. Ogni terna č del tipo (a,b,c), dove
    a,b e c sono degli interi di due cifre compresi tra 00 e 99.
    La prima riga del file di input contiene il numero di terne presenti nel file.
    Output
    Il file di output contiene la sequenza riordinata delle terne presenti nel file di input.
    Ecco le interfacce (che secondo me hanno qualche errore)

    codice:
    public interface Node {
    public Node getNext(); // ritorna il nodo successivo
    public void setNext(); // setta il valore del next                  //un parametro glielo mettiamo?
    public void setFirst(int i); // setta il primo val della terna
    public void setSecond(int i); // setta il secondo val della terna
    public void setThird(int i); // setta il terzo val della terna
    public int getFirst(int i); // ritorna il primo val della terna       //errore, non prende parametri
    public int getSecond(int i); // rit. il secondo val della terna   //errore, non prende parametri
    public int getThird(int i); // ritorna il val della terna               //non prende parametri!!!!!!
    }
    
    
    
    public interface LinkedList {
    // ritorna true se la lista č vuota
    public boolean isEmpty();
    // ritorna true se node č la testa della lista
    public boolean isHead(Node node);
    // ritorna true se node č la coda della lista
    public boolean isTail(Node node);
    // aggiunge un nuovo elemento alla lista
    public void add(Node node);
    // ritorna l'elemento pił piccolo della lista
    public void getMin();                                        //void????
    // ritorna l'elemento pił grande della lista
    public void getMax();                                       //void???
    // ritorna la testa della lista
    public Node getHead();
    // ritorna la coda della lista
    public Node getTail();
    // ritorna la dimensione della lista
    public long getSize();
    }
    Sorvolando sui miei commenti ironici dovuti alla pazienza, che penso sia in vacanza

    Il mio problema č come interpretare alcune cose.
    Intanto per il setNext() credo ci si possa passare semplicemente un Node. Ma per quanto riguarda i metodi getMin e getMax, a parte che non possono essere void, ma poi cosa si intende? min e max rispetto a che cosa?
    Come faccio a determinare su nodi che contengono triplette un minimo o un massimo?
    Mi sapreste dare un suggerimento su come fare un inserimento ordinato?
    Il problema č che non ho un valore per ogni nodo, ma una terna...da ordinare facendo si che:
    "le terne
    sono state riordinate, in senso non decrescente, in base al valore degli elementi
    contenuti nelle terne (ordinare sul primo valore; in caso di valore uguale ordinare sul
    secondo valore; in caso di uguaglianza dei primi due valori ordinare sul terzo
    valore)."


  2. #2
    Utente di HTML.it
    Registrato dal
    Feb 2007
    Messaggi
    4,157
    vai con ordine e non mischiare i concetti.
    Innanzitutto l'oggetto Node: indica un nodo della lista, contiene una terna di valori (a,b,c) e soprattutto ti consente di "comparare gli oggetti" : ti consiglio di implementare per il nodo

    codice:
    int compareTo(Node);
    in modo da sapere le regole di confronto.
    Volendo essere rigorosi, hai un'interfaccia nodo e 2 classi di implementazione, Node e NodeNull, la seconda che implementa il nodo di coda. Ma questo non ti viene chiesto al momento.
    Ricorda di inserire in Node il riferimento al successivo, non sono sicura se anche il riferimento al precedente č necessario (ma mi pare di no)

    Passiamo alla lista. Puoi mantenere un indice che indica la dimensione (ma abbi cura di aggiornarlo)
    In lista c'č il riferimento all'head della coda e tutti i metodi di gestione della lista (insert, update, remove, get)
    Hai anche getMin e getMax, che ritornano il componente minore/maggiore secondo la tua logica (e l'ordinamento ti aiuta in questo).

    Tutta questa roba viene solo dalla logica di linked list, guarda bene la definizione

  3. #3
    Bč grazie intanto della disponibilitą

    Non ho capito il discorso riguardo a NodeNull ma non credo sia da fare, non lo abbiamo mai fatto...la classe Node l'ho fatta cosģ, non sono molto convinto del compareTo.

    codice:
    public class TripleNode implements Node
    {
    	private int first,second,third;
    	private Node next;
    	
    	public TripleNode(int first,int second,int third, Node next)
    	{
    		this.first=first;
    		this.second=second;
    		this.third=third;
    		this.next=next;
    	}
    	
    	public Node getNext(){ return next;}
    	
    	public void setNext(Node n){next=n;}
    	
    	public void setFirst(int i){first=i;}
    	
    	public void setSecond(int i){second=i;}
    	
    	public void setThird(int i){third=i;}
    	
    	public int getFirst(){return first;}
    	
    	public int getSecond(){return second;}
    	
    	public int getThird(){return third;}
    	
    	public int compareTo(Node n)
    	{
    		if(this.getFirst()<n.getFirst()){
    			return -1;}
    		
    		else if(this.getFirst()>n.getFirst()){
    			return 1;}
    		
    		else if(this.getFirst()==n.getFirst())
    		{
    			if(this.getSecond()<n.getSecond()){
    			return -1;}
    			
    			else if(this.getSecond()>n.getSecond()){
    				return 1;}
    			
    			else if(this.getThird()<n.getThird()){
    				return -1;}
    				
    			else return 1;	
    				
    		
    		}
    		
    		return 0;
    	}
    	
    }
    Quante cose ho sbagliato?

    Quanto ai metodi della Lista, il setNext l'ho implementato, come richiesto, solo che si erano dimenticati di scrivere un parametro tra parentesi, quanto a getMin e getMax, ho un pņ di difficoltą a capire quando un nodo con una tripletta č maggiore o minore di un altro.
    Forse se gią vedo che il primo elemento della terna di N č minore del primo elemento della terna di n, posso concludere che N č minore?
    Se invece i primi elementi della terna sono uguali controllo i secondi, quello che ha il valore minore č pił piccolo altrimenti se sono uguali controllo sul terzo elemento?
    Basandomi sul metodo compareTo della classe Node che ho implementato (temo come al solito male).

  4. #4
    Utente di HTML.it
    Registrato dal
    Feb 2007
    Messaggi
    4,157
    hai ancora poco chiari i concetti di Node e Lista

    Un nodo quali informazioni porta con sč? Cosa descrive completamente il nodo?

    Io dico che ti basta la terna di numeri (rappresentata da 3 interi) e un node, cioč

    codice:
    public class Node{
    
        private int first; 
        private int second; 
        private int third; 
    
        private Node next; 
    }
    questo descrive completamente un nodo.
    Se tu vuoi fare una lista di persone (immagina proprio fisicamente di impilare) ad ogni persona basta sapere chi č (il suo nome) e chi viene dopo, il resto non pertiene all'oggetto.
    Stesso principio applicalo qui, ti basta sapere chi č il nodo (la tripla) e il successivo.

    Per quanto riguarda la lista, delle persone cosa ti interessa sapere? quanti ne hai, chi č il primo, come puoi aggiungerne, rimuoverne e come puoi modificare l'ordine. (esempio metterlo prima di un altro).
    In questo caso aggiungi altre funzionalitą alla lista, non direttamente necessarie (getMin() e getMax())

    Ti parlo di compare per quale motivo? Devi decidere tu quando un nodo viene prima di un altro. secondo la logica data dal tuo prof,
    Si scriva in seguito un programma Java che, utilizzando la nuova classe per la
    gestione di un insieme, prenda in input un file contenente una sequenza di terne,
    del tipo (a,b,c), e scriva in un file di output la medesima sequenza in cui le terne
    sono state riordinate, in senso non decrescente, in base al valore degli elementi
    contenuti nelle terne (ordinare sul primo valore; in caso di valore uguale ordinare sul
    secondo valore; in caso di uguaglianza dei primi due valori ordinare sul terzo
    valore).
    cioč fatti un esempio proprio matematico

    (5, 10, 15) < (6, 10, 15)

    perchč 5 < 6
    ma

    (5, 10, 10) < (5, 10, 15)

    perchč essendo i primi 2 uguali, guardi al terzo.

    Una piccola ricerca su google, ti dice che il metodo compareTo ritorna -1,0,1 a seconda se l'oggetto sia minore, uguale o maggiore dell'argomento, per cui con questo puoi ordinare.

    Il nullNode č una finezza di programmazione, infatti non č richiesto

    prima di continuare studiati bene cosa sono in teoria le liste, se lo capisci i miei suggerimenti ti fanno finire in 5 minuti.

  5. #5
    Mh, perņ non ho capito, l'unico problema di Node allora č il compareTo, per il resto l'ho implementata bene, con un costruttore che ha 3 int, e un puntatore al next come dicevi tu.
    Per quanto riguarda il minimo e il massimo, tu dici che:

    codice:
    (5, 10, 15) < (6, 10, 15) 
    
    perchč 5 < 6
    ma 
    
    (5, 10, 10) < (5, 10, 15) 
    
    perchč essendo i primi 2 uguali, guardi al terzo.
    Ma per esempio secondo te se avessi:

    codice:
    (57,51,02),(17,69,25)
    Dato che non ce ne sono uguali che faccio, mi baso solo sul primo in questo caso?
    E quindi dirņ che:

    codice:
    (57,51,02)>(17,69,25)
    ?

    Beata te che dici che sia facile...
    Ora ci ragiono un pņ...grazie.

  6. #6
    Utente di HTML.it
    Registrato dal
    Feb 2007
    Messaggi
    4,157
    ovvio.
    (57,51,02),(17,69,25)
    la regola č:
    confronta i primi due numeri 57 e 17, 57 > 17 quindi hai finito
    guardi al secondo e/o al terzo quando il primo/secondo sono uguali

  7. #7
    Bene...forse mi sono complicato un pņ la vita, il nostro professore diceva:
    "Se scrivete codice troppo lungo, cominciate a sospettare di sbagliare".
    Ho riscritto il compareTo(), mi sembra lineare come logica, spero vada bene, dopo pranzo continuo il resto del programma. Grazie intanto dell'aiuto.

    codice:
    public int compareTo(Node node)
    	{
    		
    		if(this.getFirst()!=node.getFirst())
    		{
    			if(this.getFirst()<node.getFirst())
    				return -1;
    			else return 1;
    		}
    		
    		else if(this.getSecond()!=node.getSecond())
    		{
    			if(this.getSecond()<node.getSecond())
    			return -1;
    			else return 1;
    		}
    		
    		else if(this.getThird()!=node.getThird())
    		{
    			if(this.getThird()<node.getThird())
    			return -1;
    			else return 1;
    			
    		}
    		
    		return 0;
    	}

  8. #8
    Utente di HTML.it
    Registrato dal
    Feb 2007
    Messaggi
    4,157
    il prof dice giusto, ma a volte č impossibile fare un programma con poche istruzioni (passa alle swing e ne riparliamo).
    La logica deve essere lineare, facile da capire, da implementare, da capire per chi legge il codice e non sei tu

  9. #9
    il prof dice giusto, ma a volte č impossibile fare un programma con poche istruzioni (passa alle swing e ne riparliamo).
    La logica deve essere lineare, facile da capire, da implementare, da capire per chi legge il codice e non sei tu
    Eh bč ma lui si riferiva agli esercizi č ovvio che se si fa un progetto richiederą molte pił righe di codice.
    Ma faevi un discorso in generale circa la leggibilitą di codice oppure mi facevi notare che non scrivo chiaramente per gli altri?
    Notavo che se provo ad utilizzare il compareTo, non compila il codice, perchč la classe LinkedList dove ho i nodi e utilizzo il compareTo, non trova nell'interfaccia il metodo compareTo, quindi per utilizzarlo devo per forza aggiungerlo nell'interfaccia?
    Non c'č modo per utilizzarlo senza inserirlo nell'interfaccia?
    Ora al momento gliel'ho aggiunto.....ma non si dovrebbe fare....

  10. #10
    Utente di HTML.it
    Registrato dal
    Feb 2007
    Messaggi
    4,157
    La leggibilitą del codice č un discorso generale, č una regola che si dovrebbe sempre applicare (come cercare di non scrivere metodi troppo lunghi)

    hai un po' di confusione in testa riguardo alle interfacce e al resto.
    La programmazione ad oggetti in questo caso ti consente di separare la DICHIARAZIONE di intenzioni con l'effettiva IMPLEMENTAZIONE delle stesse.

    Mi spiego. Nella maggioranza dei casi l'uso dell'interfaccia serve a te programmatore per dichiarare che ogni classe che implementa quell'interfaccia ha quelle funzionalitą, non te ne frega niente di come poi le implementa realmente.
    Se vai a guardare la struttura di List in java noti che in List c'č un metodo add(object). Tu dici che ogni implementazione di List deve consentirti l'add, poi l'ArrayList lo fa nel modo x, LinkedList nel modo y non importa, sai che in tutte e due puoi fare un add ed č l'implementazione a decidere come fai l'operazione.
    Vantaggio: puoi cambiare l'implementazione senza cambiare tutte le classi che la usano perchč riferendoti sempre alle interfacce solo runtime vai a beccare le implementazioni.
    Svantaggio: aggiungere/togliere un metodo alle interfacce puņ essere oneroso, prevede una revisione del progetto (per questo trovi spesso robe con la scritta "deprecated").
    questo č in 3 parole l'uso delle interfacce, ogni buon libro di testo java e/o la documentazione oracle ti sa indicare tutto ciņ e altro.
    A te interessa che l'oggetto nodo sia confrontabile, cioč che abbia compareTo.
    Il metodo che stai usando per il confronto č quello di rendere l'oggetto comparable, in java lo fai facendo implementare all'oggetto l'interfaccia comparable

    codice:
    The Comparable interface consists of the following method.
    
        public interface Comparable<T> {
            public int compareTo(T o);
        }
    nota che quella <T> indica il generics, cioč puoi specificare il tipo di dato usato per la comparazione.
    Nel tuo caso, o aggiungi il metodo all'interfaccia

    codice:
      public int compareTo(Node node);
    oppure dichiari la tua interfaccia che estende comparable

    codice:
      public interface Node extends Comparable<Node>
    obbligando ogni implementazione di Node a dettare le regole di confronto.

    Puoi non specificare la classe comparable, inserisci il tuo metodo compare nell'implementazione di Node, ma per usarlo dovrai (a ragione) dichiarare l'oggetto di tipo NodeImplementation, non NodeInterface.
    Tu nella realtą puoi dire

    node č dichiarato NodeInterface
    node č istanziato NodeImplementation

    puoi usare su node tutti i metodi dichiarati per NodeInterface, se compareTo non č in NodeInterface ma solo in NodeImplementation, per usarlo devi dichiararlo di tipo NodeImplementation.

    So che č un po' ostico all'inizio e non č facile spiegarlo in un post, ma tutti questi concetti se applicati bene aumentano molto la riusabilitą del codice.

    ps prima che lo dimentico: se dici che estendi Comparable nella definizione di NodeInterface non c'č bisogno di aggiungere la signature di compareTo

    spero di essere stata chiara.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.