Liste varie

di il
61 risposte

61 Risposte - Pagina 3

  • Re: Liste varie

    Bhe nello stack devo togliere i nodi che sono sopra al nodo n che voglio estrarre.
    ciò non significa che io debba troncare i collegamenti mmh

    @EDIT:
    
    public int size()
        {
            int size = 0;
            if(isEmpty())
            return 0;
            else
            {
                while(head != null)
                {
                    head = head.getLink();
                    size++;
                }
            }
            return size;
        }
    dovrebbe andare meglio mmh

    @EDIT1:
    mi sono dilettato anche con l'extract at
    
    public Node<E> extract(int index)
        {
            if(isEmpty())
            throw new EmptyStackException();
            else
            {
                Node<E> tmp = head;
                while (index > 1)
                {
                    tmp = tmp.getLink();
                    index--;
                }
                tmp.setLink(null);
                return tmp;
            }
        }
    anche se ora come ora ho seri problemi a immaginarmi come linkare i 2 nodi ai lati di quello che tiro fuori
  • Re: Liste varie

    KuroKami69 ha scritto:


    
    public int size()
        {
            int size = 0;
            if(isEmpty())
            return 0;
            else
            {
                while(head != null)
                {
                    head = head.getLink();
                    size++;
                }
            }
            return size;
        }
    dovrebbe andare meglio mmh
    No affatto. Innanzitutto il isEmpty() non servirebbe. Basta solo il ciclo come ho mostrato io per la iterazione.
    Ma c'è un dettaglio importante! NON devi toccare (=modificare) il head.

    head = head.getLink();

    Il size() non deve fare alcuna modifica alla collezione, se assegni a head vai a "rovinare" completamente la lista dei nodi.

    KuroKami69 ha scritto:


    mi sono dilettato anche con l'extract at
    
    public Node<E> extract(int index)
        {
            if(isEmpty())
            throw new EmptyStackException();
            else
            {
                Node<E> tmp = head;
                while (index > 1)
                {
                    tmp = tmp.getLink();
                    index--;
                }
                tmp.setLink(null);
                return tmp;
            }
        }
    anche se ora come ora ho seri problemi a immaginarmi come linkare i 2 nodi ai lati di quello che tiro fuori
    Eh eh .... se vuoi estrarre (=togliere) il nodo di indice index (partendo da head) c'è da ragionare un pochino.

    Dai, anche se è tardi e vorrei andare a dormire .. un bel mini grafico:

    head----> nodo0----> nodo1----> nodo2----> nodo3--null

    Se si invoca extract(0) dovrebbe rimuovere nodo0.
    Se si invoca extract(1) dovrebbe rimuovere nodo1.
    Se si invoca extract(2) dovrebbe rimuovere nodo2.
    ecc...

    Il caso particolare è: con extract(0) va modificato il head, che non è il "next" di un nodo. Insomma è un caso particolare.
    Con index > 0 invece va modificato il "next" di un nodo.
  • Re: Liste varie

    Quindi al posto di head devo usare una variabile temporanea che faccia quello che ho fatto fare a head giusto? altrimenti non mi viene in mente nient'altro. o sono veramente stupido io.
    c'è anche da dire che senza il controllo se la lista è vuota, non mi torna 0 ma mi rimanda un nullpointerexception mmh
    oppure per il size potrei semplicemente metterci una variabile di classe size e nell'add mettere size++ e nel delete/extract size-- mmh

    @EDIT:
    voglio dire, con una cosa così
    
    public int size()
        {
            int size = 0;
            Node<E> tmp = head;
            while(tmp.getLink() != null)
            {
                tmp = tmp.getLink();
                size++;
            }
            return size;
        }
    se lo stack è vuoto, mi ritorna un eccezione, se invece ho 5 elementi, mi ritorna 4...
    e credo sia perché il contatore parte da 0 e quindi da head=nodo1 -> size = 0, nodo2 -> size = 1, nodo3 -> size = 2, nodo4 -> size = 3, nodo5 -> size = 4... ma non son sicuro di averci preso mmmh
  • Re: Liste varie

    KuroKami69 ha scritto:


    
            Node<E> tmp = head;
            while(tmp.getLink() != null)
    
    Hai sostanzialmente ri-fatto lo stesso errore concettuale indicato qui.
    Vai più avanti del necessario già fin dall'inizio.
  • Re: Liste varie

    Te dici che vado più avanti del necessario, ma a me conta sempre un nodo in meno rispetto a quelli che ho dentro, quindi mi sembra che sto più indietro del necessario mmh. alla fine il size in tutte le pile viene fatto mettendo un size++/-- nei vari push e pop mmh sono tentato di fare anche io così, anche se questa soluzione sembra nettamente più interessante
  • Re: Liste varie

    KuroKami69 ha scritto:


    Te dici che vado più avanti del necessario, ma a me conta sempre un nodo in meno rispetto a quelli che ho dentro, quindi mi sembra che sto più indietro del necessario mmh.
    No, è proprio perché vai a "guardare" più avanti, che non va bene.

    Osserva bene:
            Node<E> tmp = head;
            while(tmp.getLink() != null)
    Scenario 1)
    NON ci sono nodi, quindi head E tmp sono null.
    Prova a rispondere: cosa succede nella condizione del while??

    Scenario 2)
    C'è 1 solo nodo. Quindi head E tmp fanno riferimento a quel nodo. Ma il "link" del nodo è null (non essendoci altro oltre quel nodo).
    Prova a rispondere: cosa succede nella condizione del while??
  • Re: Liste varie

    Mmmh per lo scenario 1, ho semplicemente risolto mettendoci un controllo per vedere se la lista è vuota o meno.
    se ho solo un nodo, non ci entra nemmeno nel while, perché tmp.getLink() è a null mmh
    quindi mi basta fare while(tmp != null)?
  • Re: Liste varie

    KuroKami69 ha scritto:


    Mmmh per lo scenario 1, ho semplicemente risolto mettendoci un controllo per vedere se la lista è vuota o meno.
    se ho solo un nodo, non ci entra nemmeno nel while, perché tmp.getLink() è a null mmh
    quindi mi basta fare while(tmp != null)?
    No, non serve un controllo preventivo se la lista è vuota. Basta mettere opportunamente la condizione del while.

    Quindi:
    public int size() {
        int size = 0;
        Node<E> tmp = head;
    
        while (tmp != null) {
            tmp = tmp.getLink();
            size++;
        }
    
        return size;
    }
    O se si vuole fare la cosa furba con il for:
    public int size() {
        int size = 0;
        
        for (Node<E> tmp = head; tmp != null; tmp = tmp.getLink()) {
            size++;
        }
    
        return size;
    }
    Questi sono corrretti.
  • Re: Liste varie

    La seconda soluzione mi sembra la più accattivante, quindi credo che la adotterò grazie
    effettivamente avevo provato a togliere il controllo, ma mi dava un eccezione, quindi l'ho rimesso. ma succedeva solo perché avevo impostato male il while.
    invece, ci ho pensato per 1h e non ne ho cavato niente, non riesco a capire come linkare 2 nodi dopo averne tolto uno in mezzo. fino a toglierlo, ci sono, poi non riesco a capire come attaccare i 2 pezzi mmh
  • Re: Liste varie

    KuroKami69 ha scritto:


    invece, ci ho pensato per 1h e non ne ho cavato niente, non riesco a capire come linkare 2 nodi dopo averne tolto uno in mezzo. fino a toglierlo, ci sono, poi non riesco a capire come attaccare i 2 pezzi mmh
    Ti riferisci al extract(index) che toglie il solo nodo a index? Innanzitutto c'è il caso particolare di extract(0) che è da trattare diversamente da index > 0.
    Poi comunque devi considerare altri scenari: se chiedi extract(6) ma hai solo 3 nodi?

    E come "indizio" finale: mentre stai cercando il nodo al index, mantieni anche (altra variabile) il nodo "precedente". Se esiste e trovi il nodo a index, avendo il precedente puoi far "saltare" il nodo trovato.
  • Re: Liste varie

    Per l'inserimento di un index maggiore della size della lista, posso gestire facendo un controllo tra size e index, se index è maggiore, mi manda fuori un errore. credo intendessi questo. onestamente, per il caso di index = 0, con il codice attuale, funziona, ma non credo sia corretto, perché ritornerei head e non il nodo, giusto? l'unica cosa che mi viene in mente è un head.getLink() ma dovrebbe essere sbagliata ahaha

    per il link invece... intendi che oltre a tmp devo usare un'altra variabile? e bloccare l'assegnazione ad essa 1 step precedente a tmp e farci un rel = rel.getLink().getLink()?
  • Re: Liste varie

    KuroKami69 ha scritto:


    Per l'inserimento di un index maggiore della size della lista, posso gestire facendo un controllo tra size e index, se index è maggiore, mi manda fuori un errore.
    Se sfrutti e invochi size() che è implementato iterativamente (come mostrato prima), allora no. La complessità del extract sarebbe doppia.

    KuroKami69 ha scritto:


    per il caso di index = 0, con il codice attuale, funziona, ma non credo sia corretto, perché ritornerei head e non il nodo, giusto?
    Forse non ti è ancora chiarissimo che head, se non-null, È il primo nodo.

    KuroKami69 ha scritto:


    per il link invece... intendi che oltre a tmp devo usare un'altra variabile? e bloccare l'assegnazione ad essa 1 step precedente a tmp e farci un rel = rel.getLink().getLink()?
    Troppo fumoso/dubbio. L'ho già detto altre volte: per programmare bisogna sforzarsi (un po') di "ragionare".

    Oggi non ho molto tempo per impegni personali ma appena posso provo ad implementarlo e poi ti do gli indizi più giusti.
  • Re: Liste varie

    Quindi mi va bene ritornare head e non vedo il problema con quanto ho fatto io.
    detto questo, ho dormito poco e sono decisamente stanco. magari dopo una dormita ingrano meglio
  • Re: Liste varie

    Se vuoi implementare il extract(index), non è difficile (io l'ho scritto e provato in 5 min.)

    Innanzitutto devi gestire il caso ovvio di lista vuota. Devi poi distinguere tra index=0 e index>0 .
    Il caso index=0 è banale, perché è praticamente uguale al extract() semplice che hai già fatto in quanto basta aggiornare il head per togliere il nodo indice 0.
    Il caso index>0 è solo un po' più articolato. Devi scorrere finché trovi l'elemento da estrarre. Dovresti scorrere sui nodi fino a quando: hai terminato il conteggio O trovi un null. Dettaglio importante, dovresti tenerti anche il nodo "precedente". Dato che in questo scenario index > 0, un nodo precedente lo avrai sempre. Questo ti servirà per far "saltare" il nodo estratto.

    Se dopo lo scorrimento sui nodi hai un nodo non-null, l'hai trovato. Se è null vuol dire che è stato chiesto un index troppo "avanti". In tal caso puoi lanciare una eccezione es. IndexOutOfBoundsException.

    Ah, se viene passato index < 0 ha senso lanciare subito una eccezione es. IndexOutOfBoundsException.
  • Re: Liste varie

    A livello di logica, sono arrivato alle stesse conclusioni, ma non riesco a fare il codice, sto pensando a un sacco di modi per collegare i 2 nodi dopo l'estrazione ma niente che mi convince. L'ultima idea era di usare un array dove caricare i nodi estratti e poi ricaricarli nella pila, ma mi sembra troppo laboriosa come cosa. Perchè li devo distinguere i 2 index 0? Voglio dire, attualmente, se metto 0 mi ritorna il primo nodo e funziona. Non mi pare di dover fare un else if dedicato a index == 0 mmh
Devi accedere o registrarti per scrivere nel forum
61 risposte