22 Liste – Eliminazione e Garbage Collector

Dopo aver creato la nostra lista nel primo articolo dedicato alle liste e dopo aver visto come si inseriscono gli elementi adesso vediamo come eliminare i nodi della nostra lista.
Ipotiziamo sempre di avere una lista di numeri e che ogni metodo torni al chiamante il valore del numero del nodo che ha eliminato oppure -1 se non elimina niente. Anche in questo caso potremmo effettuare tre diversi tipi di eliminazioni, vediamoli in ordine:

Eliminazione in TESTA

public int eliminazione_in_Testa(int dato)
{
    if(n!=null)
    {
        int valore=n.numero;
        n=n.successivo;
        if(n!=null)//controllo che ci sia almeno un altro nodo
            n.precedente=null;//solo se la lista è doppiamente concatenata
        return valore;
    }
    return -1;
}

Eliminazione in CODA

public int eliminazione_in_Coda(int dato)
{
    if(n!=null)
    {            
        if(n.successivo==null)//c'è un solo elemento
            return eliminazione_in_Testa(dato);
        else
        {
            int valore;
            Nodo tmp=n;
            while(tmp.successivo.successivo!=null)//mi fermo sul penultimo nodo
                tmp=tmp.successivo;
            valore=tmp.successivo.numero;
            tmp.successivo=null;//elimino nodo in coda
            return valore;
        }
    }
    return -1;
}

Eliminazione ORDINATA

public int eliminazione_Ordinato(int dato,int posizione)
{
    if(n!=null)
    {
        int valore;
        if(posizione==1)
            return eliminazione_in_Testa(dato);
        else
        {
            Nodo tmp=n;
            int i=2;
            while(i<posizione && tmp.successivo!=null)//mi fermo sul nodo precedente a quello 
            {
                tmp=tmp.successivo;//che devo eliminare
                i++;
            }
            if(tmp.successivo==null && i==posizione)
                return eliminazione_in_Coda(dato);//devo eliminare la coda
            else
            {//devo eliminare una cella intermedia
                valore=tmp.successivo.numero;
                /* con il prossimo comando aggiorno il nodo precedente del
                nodo successivo a quello che devo eliminare*/
                tmp.successivo.successivo.precedente=tmp;//solo se la lista è doppiamente concatenata
                /*con il prossimo comando il nodo precedente a quello che devo eliminare punterà
                al nodo successivo a quello che devo eliminare*/
                tmp.successivo=tmp.successivo.successivo;
                return valore;

            }
        }
    }
    return -1;
}

Garbage Collector
Quando eliminiamo un nodo nella memoria ci troveremo in una situazione simile a quella rappresentata dalla figura sottostante.

22.1
Che fine fa il nodo che adesso non è più collegao a niente e quindi inutilizzato dal programma?
In C dobbiamo occuparci noi di deallocare le celle di memoria inutilizzate altrimenti occupiamo memoria per niente. In Java, come in altri linguaggi, non è così, anzi è un po’ il contrario. Noi non possiamo accedere direttamente alle celle di memoria ma sarà il sistema operativo, tramite una procedura detta Garbage Collector (letteralmente “raccoltà dei rifiuti”), ad eliminare dalla memoria qualsiasi dato che non sia più direttamente collegato con il programma in funzionamento.
Questa procedura presenta due vantaggi:
1) Non dobbiamo occuparci di deallocare la memoria che non usiamo più (e quindi i nodi non puntati più da nessuno in questo caso specifico), pro molto evidente
2) Il sistema operativo deciderà quando è opportuno liberare la memoria inutilizzata in modo da rendere il processo il più efficente possibile

Finisce qui l’articolo. Adesso che abbiamo appreso il concetto di lista vedremo fra due articoli Grafi e Alberi!
Prima di questo vi mostrerò due “trucchetti” per gestire gli errori.
Insomma non perdetevi i prossimo articoli perchè sono veramente due degli argomenti più interessanti secondo me. Perchè? Leggeteli e lo scoprirete!

Please follow and like us: