Newsgroup: it.comp.lang.c
Titolo: Sempre io....se mai ci capirò qualcosa vi faccio un regalo!

Dopo aver capito la soluzione al problema della stringa Pippo datami da
Andrea Laforgia (mi dispiace per antirez ma in tutto quel mescolone di
graffe, senza vedere funzioni che mi hanno insegnato ad usare, non ci tolgo
le gambe) adesso si pone il problema di avere un' idea chiara di come
inserire, cancellare ecc. in liste, stack e queue.
Negli appunti che ho, ho trovato 2 tipi di inserimento, uno ricorsivo
(proprio come quello di Andrea Laforgia) e uno no (ma non saprei dire
com'č.....iterativo? Boh), adesso mi viene da chiedermi se si possa usare o
l'uno o l'altro a mio piacimento o no. I due esempi di funzione di
inserimento li scrivo sotto. Ciň che mi fa venire il dubbio č che quello non
ricorsivo venga usato sul mio libro in un esempio (l'unico......accidenti a
lui) nel quale prende dei valori e li ordina.......non a caso, credo che usi
i puntatori "previousptr", "correntptr" e "newptr"..........in questi caso
potevo
usare quello ricorsivo o no? E come?
void insert(pnodo *pHead, char c)                   /* quello ricorsivo */
{
     if (!*pHead)
     {
        *pHead = malloc(sizeof(nodo));
        (*pHead)->c = c;
        (*pHead)->next = 0;
     }
     else
       insert(&(*pHead)->next, c);
}
void insert(listnodeptr *sptr,char value)        /* l'altro */
{
listnodeptr newptr,previousptr,currentptr;
newptr = malloc(sizeof(LISTNODE));
if(newptr != NULL)
newptr->data=value;
newptr->nextptr=NULL;
previousptr=NULL;
currentptr=*sptr;
}
Sofia

 se ho detto una cacchiata correggetemi ;p
In effetti mesà anche a me ... tra l'altro viene allocato un puntatore
all'interno della funzione, ma se non viene assegnato ad una variabile
globale o ritornato dalla funzione stessa, resta svolazzante.
Sofia, sei sicura che la funzione sia corretta?
Ciao,
Cecco

 ha scritto nel messaggio
news:6G598.41619$om6.1...@news1.tin.it...

Ci sta benissimo, ma non è roba mia, l'ho solo copiata!
Sofia

 void insert(listnodeptr *sptr,char value)        /* l'altro */
Questa mi sembra incompleta. Non fa nulla di utile.
/* Inserimento non ricorsivo in coda */
void insert(pnodo *pHead, char c) {
	pnodo tmp;
	if (*pHead == NULL) {
		*pHead = malloc(sizeof(nodo));
		assert(*pHead);
		(*pHead)->next = NULL;
		(*pHead)->c = c;
		return;
	}
	tmp = *pHead;
	while(tmp->next)
		tmp = tmp->next;
	tmp->next = malloc(sizeof(nodo));
	assert(tmp->next);
	tmp = tmp->next;
 
	tmp->next = NULL;
	tmp->c = c;
}
/* Inserimento non ricorsivo ordinato */
void insert(pnodo *pHead, char c) {
	pnodo *tmp, *p;
	if (*pHead == NULL) {
		*pHead = malloc(sizeof(nodo));
		assert(*pHead);
		(*pHead)->next = NULL;
		(*pHead)->c = c;
		return;
	}
	tmp = NULL;
	p = *pHead;
	/* Scorro la lista in avanti finche` trovo un elemento maggiore
	 * di quello che devo inserire. Inserisco prima dell'elemento
	 * corrente (tramite il puntatore tmp)
	 */
	while (p && p->c < c) {
		tmp = p;
		p = p->next;
	}
	p = malloc(sizeof(nodo));
	assert(p);
	if (tmp == NULL) {
		/* tmp e` ancora NULL: il ciclo non e` stato eseguito.
		 * Devo aggiungo in testa
		 */
		 p->next = *pHead;
		 *pHead = p;
		 return;
	}
	p->next = tmp->next;
	tmp->next = p;
}
Nota che con
while (p && p->c < c)
non rischio  di dereferenziare un  puntatore nullo, perche`  l'ordine di
valutazione dell'espressione e` da sinistra  a destra e la seconda parte
(p->c < c) viene valutata solo se (p != NULL).
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Quando un uomo porta dei fiori a sua moglie senza motivo, 
un motivo c'e`.