Liste varie

di il
61 risposte

61 Risposte - Pagina 4

  • Re: Liste varie

    KuroKami69 ha scritto:


    sto pensando a un sacco di modi per collegare i 2 nodi dopo l'estrazione ma niente che mi convince.
    Se index > 0 e hai il nodo da estrarre e il nodo precedente .... banalmente:

    prev.setLink(node.getLink());

    Sì, basta questo per far "saltare" il node trovato (prev = previous, precedente).

    KuroKami69 ha scritto:


    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.
    Troppo contorto.

    KuroKami69 ha scritto:


    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
    Sì che devi, perché se index = 0 devi aggiornare head. Altrimenti se index > 0 devi aggiornare il "link" del nodo precedente (vedi sopra). Non lo puoi generalizzare.
  • Re: Liste varie

    Ma quel prev è una variabile che ti sei inventato te o una funzione vera e propria?
  • Re: Liste varie

    KuroKami69 ha scritto:


    Ma quel prev è una variabile che ti sei inventato te o una funzione vera e propria?
    È ovviamente una variabile, la devi definire tu ed aggiornare durante il ciclo di scansione dei nodi per tenere il nodo "precedente" rispetto al nodo che man mano trovi.
  • Re: Liste varie

    Ma ci avevo pensato ad una cosa simile, e l'avevo anche fatta, solo che non mi ha funzionato... avevo fatto girare il while fino a index -1, così da fermarmi al nodo prima di quello da estrarre, poi assegnato a tmp = actual.getLink(), poi assegnavo ad actual il link del nodo successivo actual.setLink(actual.getLink), e mettevo il link di tmp a null. ma non mi funzionava.
    è questo che intendi te?
  • Re: Liste varie

    KuroKami69 ha scritto:


    Ma ci avevo pensato ad una cosa simile, e l'avevo anche fatta, solo che non mi ha funzionato... avevo fatto girare il while fino a index -1, così da fermarmi al nodo prima di quello da estrarre, poi assegnato a tmp = actual.getLink(), poi assegnavo ad actual il link del nodo successivo actual.setLink(actual.getLink), e mettevo il link di tmp a null. ma non mi funzionava.
    è questo che intendi te?
    Anche fermarsi al nodo precedente (ma potendo comunque accedere al nodo da estrarre) è una possibile soluzione, non l'ho provata. Ma devi fermarti al punto giusto, perché devi arrivare a trovare il nodo in questione oppure null (ricorda il caso di extract con indice "troppo" avanti per i nodi che hai).

    Mi viene da pensare che avresti forse bisogno di esercitazioni PIÙ semplici, perché queste sulle strutture dati forse sono troppo ostiche per te ..
  • Re: Liste varie

    Probabile, ma se non le faccio non ci riuscirò mai una volta fatte, 2-3 volte, dopo non dovrei più avere problemi con queste cose.
    quindi, sistemo il codice e lo allego a questo messaggio con un edit

    @EDIT:
    credo di averlo fatto giusto. credo.
    
    public Node<E> extract(int index)
        {
            if(isEmpty())
            throw new NoSuchElementException("la pila è vuota");
            else if (index == 0)
            {
                Node<E> tmp = top;
                top = top.getLink();
                tmp.setLink(null);
                return tmp;
            }
            else if (index < 0)
            throw new IndexOutOfBoundsException("non puoi inserire un numero negativo come indice");
            else
            {
                Node<E> prev = top;
                while (index-1 > 0)
                {
                    if(prev.getLink() == null && index > 0)
                    throw new IndexOutOfBoundsException("pila di grandezza inferiore all'indice inserito");
                    else
                    {
                        prev = prev.getLink();
                        index--;
                    }
                }
                Node<E> tmp = prev.getLink();
                prev.setLink(prev.getLink().getLink());
                tmp.setLink(null);
                return tmp;
            }
        }
    ho modificato un attimo anche il delete
    
    public void delete()
        {
            if(isEmpty())
            throw new NoSuchElementException("la pila è vuota");
            else
            {
                Node<E> tmp = top;
                top = top.getLink();
                tmp.setLink(null);
            }
        }
    prima non gestivo il caso in cui potrei avere un solo nodo

    @EDIT2:
    onestamente preferisco fare un confronto tra size() e index, per vedere se l'indice inserito è valido o meno.
    mi sto incasinando troppo mmh così com'è ora, se metto tipo -3 o 7 (ho 5 nodi), mi lancia l'eccezione a random

    @EDIT3:
    le modifiche fatte al delete non servivano ahahahaha

    @EDIT4:
    ok ultimo edit promesso ahahahaha
    ho sistemato il codice, lo modifico anche qua, il delete l'ho rimesso come prima e ho sistemato 2 cosette nell'extract at index
    tecnicamente potrei fare anche un delete at index, che funziona come l'extract at index, solo che non mi ritorna il nodo. ok lo faccio, tanto è un copia e incolla adattato
  • Re: Liste varie

    KuroKami69 ha scritto:


    credo di averlo fatto giusto. credo.
    
    public Node<E> extract(int index)
        {
            if(isEmpty())
            throw new NoSuchElementException("la pila è vuota");
            else if (index == 0)
            {
                Node<E> tmp = top;
                top = top.getLink();
                tmp.setLink(null);
                return tmp;
            }
            else if (index < 0)
            throw new IndexOutOfBoundsException("non puoi inserire un numero negativo come indice");
            else
            {
                Node<E> prev = top;
                while (index-1 > 0)
                {
                    if(prev.getLink() == null && index > 0)
                    throw new IndexOutOfBoundsException("pila di grandezza inferiore all'indice inserito");
                    else
                    {
                        prev = prev.getLink();
                        index--;
                    }
                }
                Node<E> tmp = prev.getLink();
                prev.setLink(prev.getLink().getLink());
                tmp.setLink(null);
                return tmp;
            }
        }
    No, non è ancora corretto. Se lo stack ha 4 nodi (indici 0, 1, 2, 3) e tu chiedi extract(4) ti becchi un NullPointerException

    Inoltre (ma sono finezze):
    - il test per indice negativo andrebbe per primo (è una precondizione/specifica del metodo, non c'entra se lo stack è vuoto o no)
    - se vuoto, meglio es. EmptyStackException
  • Re: Liste varie

    Ma deve ritornare l'eccezione, perché non ci sono elementi all'indice 4, mi pare corretto no? se l'indice parte da 0, e ho 5 elementi, il mio indice va da 0 a 4. e se metto 4 ritorna il primo elemento immesso. se metto 5, non esiste un indice 5, quindi mi da l'eccezione. non è corretto ragionare così?
    ok non mi lancia l'eccezione che ho messo io...
    ah ora ho capito... devo gestire anche l'assegnazione qualora io tolga l'ultimo nodo
  • Re: Liste varie

    KuroKami69 ha scritto:


    Ma deve ritornare l'eccezione, perché non ci sono elementi all'indice 4, mi pare corretto no?
    Si ma NON un "brutto" NullPointerException dovuto al fatto che inappropriatamente invochi un metodo su un null !!
  • Re: Liste varie

    
    public Node<E> extract(int index)
        {
            if (index < 0)
            throw new IndexOutOfBoundsException("non puoi inserire un numero negativo come indice");
            else if(isEmpty())
            throw new  EmptyStackException();
            else if (index == 0)
            {
                Node<E> tmp = top;
                top = top.getLink();
                tmp.setLink(null);
                return tmp;
            }
            else
            {
                Node<E> prev = top;
                while (index-1 > 0 || prev.getLink() == null)
                {
                    if(prev.getLink() == null && index > 0)
                    throw new IndexOutOfBoundsException("pila di grandezza inferiore all'indice inserito");
                    else
                    {
                        prev = prev.getLink();
                        index--;
                    }
                }
                Node<E> tmp = prev.getLink();
                if (prev.getLink().getLink() != null)
                prev.setLink(prev.getLink().getLink());
                else
                prev.setLink(null);
                tmp.setLink(null);
                return tmp;
            }
        }
    ora funziona bene. dovrebbe essere giusto no?
    stesse modifiche apportate anche al delete at index
  • Re: Liste varie

    KuroKami69 ha scritto:


    ora funziona bene. dovrebbe essere giusto no?
    Lo verifico più tardi ma comunque mi pare un po' .. contorto.
  • Re: Liste varie

    Scusa, te come lo hai fatto? ahaha
    nella FIFO devo avere 2 puntatori, head e tail giusto? lo head per estrarre, il tail per aggiungere. altrimenti, usando solo l'head, dovrei fare un while per l'add
  • Re: Liste varie

    KuroKami69 ha scritto:


    nella FIFO devo avere 2 puntatori, head e tail giusto? lo head per estrarre, il tail per aggiungere. altrimenti, usando solo l'head, dovrei fare un while per l'add
    Indichiamo innanzitutto con "head" il riferimento al primo nodo la cui catena prosegue con il next in avanti. E con "tail" il mantenimento del riferimento all'ultimo nodo (quello che ha next=null).

    Come hai visto dallo stack, aggiungere E rimuovere al head è facile e veloce. Mantenendo il tail, è facile e veloce solo aggiungere in coda ma non rimuovere.
    Per rimuovere dal tail, o fai la scansione partendo dal head oppure fai la catena di nodi doubly-linked, doppiamente linkata.

    Quindi per una coda semplice, è sufficiente head (da cui rimuovi) e il tail (in cui aggiungi). E non serve per forza doppiamente linkata.

    Una coda in cui invece si può aggiungere e rimuovere da entrambi i lati si chiama "deque" (si pronuncia "deck").
  • Re: Liste varie

    Ahahaha prima ho chiesto alla prof. se andasse bene il codice che ho scritto. e ha detto che anzitutto per la queue, un codice "raffinato" usa un solo puntatore che punta all'ultimo nodo inserito.
    poi ha detto che il delete e il get at index sono fatti per una lista libera, non per una LIFO/FIFO, che il metodo corretto per farli sarebbe stato impilare i nodi in una lista temporanea e una volta preso/rimosso il nodo interessato, rimetterli dentro. son rimasto senza parole
  • Re: Liste varie

    KuroKami69 ha scritto:


    ha detto che anzitutto per la queue, un codice "raffinato" usa un solo puntatore che punta all'ultimo nodo inserito.
    "raffinata" in quel senso sì, è vero. Si può usare solo il riferimento tail ma l'ultimo nodo deve puntare al primo, diventando quindi una lista di nodi "circolare".
    E il tutto va ovviamente gestito molto attentamente e accuratamente (prova a pensare perché ..).

    KuroKami69 ha scritto:


    poi ha detto che il delete e il get at index sono fatti per una lista libera, non per una LIFO/FIFO
    In effetti operazioni "a indice" per pile/code non sono il massimo e un po' snaturano il senso di quella collezione.
    Ma qui stiamo parlando di esercitazioni .. o di finezze?

    KuroKami69 ha scritto:


    che il metodo corretto per farli sarebbe stato impilare i nodi in una lista temporanea e una volta preso/rimosso il nodo interessato, rimetterli dentro. son rimasto senza parole
    "nì", sì è possibile ma non necessariamente.
Devi accedere o registrarti per scrivere nel forum
61 risposte