Newsgroup: it.comp.lang.c
Titolo: Scorrere lista indefinita

Immaginiamo di avere una lista, la classica fatta di tanti nodi e con null
al fondo.(si chiama pila o stack?)
Immaginiamo di dover scorrere più volte questa lista, ad esempio per
ricerche, modifiche e algoritmi di ordinamento.
Pensate ad un "stupido" bubble sort non ottimizzato che deve ripetere n^2
cicli for.
Non conoscendo a priori la dimensione come si fanno ad imbastire i limiti
del ciclo?
Contare da quanti nodi è composta la lista e poi usare questo numero per
definire i limiti è una cosa furba?
Oppure bisogna usare cicli che facciano uso del solito "
puntatore=puntatore->prossimo " all'infinito finchè non trovo NULL?
In questo ultimo caso se, come da precedente post, gestisco la lista in modo
dinamico e con richiami per indirizzo mi devo creare delle liste
"clonate"(che hanno lo stesso numero di elementi della lista "puntata") da
usare come indicatori per definire i limiti dei cicli? Perchè se uso la
lista stessa come riferimento del ciclo arrivato a null mi fermo e non
riparto più!

 riparto piů!
Continui a parlare di "liste puntate" il cui senso ancora mi sfugge.
Se i miei esempi passati ti sono chiari, non dovrebbe essere difficile,
per te, lavorare con le liste.  Non riesco ad afferrare il concetto di
quanto hai scritto in quest'ultima parte...
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 quanto hai scritto in quest'ultima parte...
Immaginiamo una lista da n elementi, sopra mi hai detto che non è furbo
contare gli elementi e quindi non li conteremo, non lo sappiamo.
Scorriamo la lista finchè trovo NULL come mi hai consigliato, a quel punto
la avrò letta tutta, sono a NULL.
Adesso devo ri-scorrere la lista tante volte quate sono gli elementi. Come
faccio che sono a NULL?
Mi devo creare un altro ciclo esterno che come limite ha l'arrivo a NULL e
come passo il puntatore a elemento successivo.
Ora se con la lista principale sono arrivato a NULL, per tenere conto di
dove sono mi devo creare una altra lista identica alla lista principale con
il solo scopo di tenere traccia della posizione.
Perchè se la lista è la stessa, anche quella sarà finita a NULL? Quindi
devono essere 2 cose diverse altrimenti si ferma subito il ciclo perchè
tutte e 2 le liste vanno subito a NULL contemporaneamente.
Una cosa così:
--Lista principale;
--Lista secondaria;
--secondaria=principale;
--while secondaria divero da NULL
--{
-----while principale diverso da NULL
------{.....
-------puntatore=puntatore->prossimo ;
-------}
---puntatore=puntatore->prossimo;
--}
o ci sono altri modi?

 faccio che sono a NULL?
p2 = head;
while (p2) p2=p2->next;


 while (p2) p2=p2->next;
Quindi usi 2 liste uguali, p1 e p2? Come ho fatto io nell'esempio.
Anzi forse sarebbe meglio dire "usi 2 identificatori di lista p1 e p2 che
scorrono la stessa lista head"?
E se avevo usato una lista per indirizzo come facevo a crearmi una altra
lista di appoggio sempre per indirizzo?
*p1=*head non mi pare che funziona.

 lista di appoggio sempre per indirizzo?
Tu ti confondi sul concetto di "lista".  In C non esiste, come ti è stato
già detto, il tipo "lista" built-in, ma si implementa mediante puntatori,
quindi che cosa tu intenda per "liste uguali" o "lista per indirizzo" è
tutto da definire.  I puntatori p1 e p2 hanno inizialmente lo stesso
valore, poi uno scorre indipendentemente dall'altro verso il valore
sentinella NULL.
