Newsgroup: it.comp.lang.c
Titolo: [Liste] Inserimento in testa

Ciao a tutti!
a momenti ho esami di informatica e stavo studiando le liste (GRR!! LE ODIO! 
:)
avevo mi date un'occhiatina a questo Inserimento in testa?
la teoria c'è...però non riescoa metterla in pratica (le liste.. il resto 
più o meno me la cavicchio) .. :((
InserimentoInTesta (void *Head, int valore)
      {
        NODO **NewHead;
        NODO **TmpHead;
        NODO *NuovoNODO;
        NuovoNODO = (NODO *)malloc(sizeof(NODO));
        NuovoNODO->numero = valore;
        TmpHead=(NODO **)Head;
        NuovoNODO->next=(NODO*)TmpHead;
        Head=(NODO **)NuovoNODO;
        return;
      }
...una correzione commentata mi farebbe piacere :)) 
grazie
ciao!
-- 
Take these plastic people
Read their lips, now let it linger
Is there anything that makes them sound sincere?
I remeber falling I remember marching
like a One Man Army
Proud to be 100% Microsoft Free
Remove windows to reply

OnEmAnArMy wrote:
Assumento che la struttura dati e la lista siano cosi':
<code>
typedef struct NODO {
    int data;
    struct NODO *next;
} NODO;
NODO *list;
</code>
La funzione per l'inserimento in testa sara' (non l'ho provato):
<code>
int list_head_insert (NODO **list_head, int value) 
{
    NODO *tmp;
    if (!list_head)
        return 0;
    if (!(tmp = malloc(sizeof(NODO)))
        return 0;
    tmp->data = value;
    if (NULL == *list_head) {
        *list_head = tmp;
        (*list_head)->next = NULL;
    }
    else {
        tmp->next = *list_head;
        *list_head = tmp;
    }
    return 1;
}
</code>
Se vuoi passare un void * oki, anche se in questo caso non ne vedo 
l'utilita', basta che ti ricordi di passare l'indirizzo della lista.
<code>
NODO *list
list_head_insert (&list, 10);
</code>
E poi nella funzione assegnare "list_head" a un "NODO **". Codice che non ti 
scrivo, visto che lo reputo inutile... se vuoi usare un void * usalo per i 
dati contenuti, non per l'indirizzo della struttura dati.
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 InserimentoInTesta (void *Head, int valore)>       {
         NODO *NuovoNODO;
         NuovoNODO = (NODO *)malloc(sizeof(NODO));
         NuovoNODO->numero = valore;
         NuovoNODO->next=Head;
	Head=NuovoNODO;
         return;
       }
Allora Head è un puntatore ad una lista (a qualcosa cmq)
crei il tuo bel nodo nuovo, lo colleghi all'inizio della lista:
head e next sono due puntatori non serve fare altro.
quindi la testa punta al nuovo nodo.
-- 
Strhad
per stupire mezz'ora basta un libro di storia,
io cercai di imparare la Treccani a memoria... [F.d.A.]


Io farei ritornare ad InserimentoInTesta una struct nodo *, in modo da
usare la funzione piu` o meno cosi`:
listhead = list_insert_head(listhead, data);
E sarebbe piu` o meno una cosa simile:
struct nodo *list_insert_head(const struct nodo *n, const void *data)
{
    struct nodo *new_node = 
        (struct nodo *) my_malloc(sizeof(struct nodo));
    new_node->data = data;
    new_node->next = n;
    return new_node;
}
Un consiglio: da` un occhio ai sorgenti della glib
( 
http://www.gtk.org/
 )
che implementano questo ed altro, in maniera pulita ed efficiente :).
PS: my_malloc() interpretala come una malloc() che in caso di fallimento
dell`allocazione automaticamente chiama abort() o chi per lei.
-- 
void

 ...una correzione commentata mi farebbe piacere :))
Eccola (attenzione: non provata!):
// Il passaggio di Head per doppio puntatore ne consente la modifica
void InserimentoInTesta (NODO **Head, int valore)
{
    NODO *NuovoNODO;
    NuovoNODO = malloc(sizeof(NODO));  // Alloco il nuovo elemento
    NuovoNODO->numero = valore;  // Ne assegno il valore
    NuovoNODO->next=*Head;  // Il prossimo è quello a cui puntava testa
    *Head=NuovoNODO;  // Modifico testa che ora punta al nodo nuovo
}
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

 quindi la testa punta al nuovo nodo.
Solo la copia locale che poi viene persa alla fine della funzione. La
Head originale resta invariata a meno di non restituirne e quindi
assegnarne il valore (soluzione consigliata) o passarla come doppio
puntatore (puntatore a puntatore).
