Newsgroup: it.comp.lang.c
Titolo: Liste

Ciao ragazzi... devo fare una relazione sulle liste realizzate tramite
struct, mi sapreste indicare qualche documento dove reperire informazioni
sul web?
Io ho usato oltre al libro del docente un testo "Programmare in C guida
completa" ma non è molto esplicativo sull'argomento... per quanto riguarda
le struct tutto ok, ma le liste?!?
un'altra e ultima domanda: cosa si intende per merge di 2 liste?
Grazie a tutti ciao!
--------------------------------
Inviato via 
http://usenet.libero.it

 un'altra e ultima domanda: cosa si intende per merge di 2 liste?
Il processo per cui da 2 liste ne ottieni una sola. Il modo con cui lo fai,
dipende da cosa vuoi ottenere.
Ti faccio un esempio semplice: concateni una lista in coda ad un'altra.
<code>
list *L1, list *L2;
list *list_prepend(list *pre, list *post)
{
    if (pre == NULL)
        return post;
    while (pre->next != NULL)
        pre = pre->next;
    pre->next = post;
    return pre;
}
</code>
-- 
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."

 </code>
con pre->next specifichi che pre "punta" a next?


 con pre->next specifichi che pre "punta" a next?
No. L'operatore "->" si applica ad un puntatore ad una struttura, e serve ad
accedere ad un determinato campo della struttura a cui punta il puntatore;
l'operatore "." serve allo stesso scopo, ma si applica direttamente ad un
oggetto di quella struttura. Ad esempio:
struct S {
    int a;
    struct S *next;
};
struct S s, *p;
p = &s;
Date queste definizioni puoi accedere ai membri di s in questo modo:
s.a;
s.next;
p->a;
p->next;
Ovviamente se tenti di scrivere s->a o p.a commetti un errore sintattico che
viene segnalato dal compilatore.
Ciao

 </code>
Temo ti serva una variabile temporanea per mantenere la testa della
lista:
list *list_prepend(list *pre, list *post) {
        list *head;
        if (pre == NULL)
                return post;
        head = pre;
        while (pre->next != NULL)
                pre = pre->next;
        pre->next = post;
        return head;
}
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Al termine di un pranzo di nozze mi hanno dato un
amaro alle erbe cosi' schifoso che perfino sull'etichetta
c'era un frate che vomitava.

 lista:
"Temo" anch'io :P Succede quando scrivi le cose al volo senza provarle, a me
in particolar modo :)
Sorry per l'inconveniente.


 direttamente ad un oggetto di quella struttura. Ad esempio:
Una piccola aggiunga, che trovi su qualunque libro serio, ma che dal post di
Wonderboy non ricavavi in modo esplicito.
L'operatore "->" e' solo una scorciatoia.
Per accedere al campo X di una struttura attraverso un puntatore a struttura
P dovresti fare:
(*P).X
per via delle regole di precedenza degli operatori rispetto all'ordine in
cui tu vuio che siano valutati i vari operatori.
Detto in 2 parole: tu vuoi deferenziare il puntatore e poi accedere al campo
della struttura, se non metti le parentesi prima accede al campo del
puntatore (errore) e poi cerca di deferenziarlo.
Questa scrittura e' lenta e macchinosa, ma capita frequentemente. Proprio
per ovviare hanno implementato l'operatore "->", che ti permette di
scrivere
P->X.
