Newsgroup: it.comp.lang.c
Titolo: LISTA - inserire un carattere in ordine alfabetico

Ciao
come da oggetto, ma sto avendo problemi....
mi aiutereste ad analizzare il codice che ho scritto?
many thx
#include <stdio.h>
#include <stdlib.h>
typedef struct nodo *ptr;
typedef struct nodo
{
         char carattere;
         ptr prossimo;
}listNodo;
ptr Lista = NULL;
void inserisci(char c, ptr lis);
void inserisci(char c, ptr lis)
{
      ptr prec,prox,tmp;
      tmp = (ptr)malloc(sizeof(listNodo));
      tmp->carattere = c;
      tmp->prossimo = NULL;
      prox = lis;
             prec = prox;
             while((prox != NULL))
             {
              if(prox->carattere == c)
              {
               printf("carattere gia presente..\n");
               return;
              }
              if(c < prox->carattere)
              {
               tmp->prossimo = prec;
               prec = tmp;
              }
              if(c > prox->carattere )
              {
               tmp->prossimo = prox->prossimo;
               prec = tmp;
              }
              prec = prox;
              prox = prox->prossimo;
             }
}
int main()
{
   int b = 28;
   ptr tmp;
    //primo elemento
    tmp = (ptr)malloc(sizeof(listNodo));
    tmp->carattere = 'a';
    tmp->prossimo = Lista;
    Lista = tmp;
    //secondo elemento
    tmp = (ptr)malloc(sizeof(listNodo));
    tmp->carattere = 'b';
    tmp->prossimo = Lista;
    Lista = tmp;
    //terzo elemento
    tmp = (ptr)malloc(sizeof(listNodo));
    tmp->carattere = 'd';
    tmp->prossimo = Lista;
    Lista = tmp;
    //quarto elemento
    tmp = (ptr)malloc(sizeof(listNodo));
    tmp->carattere = 'z';
    tmp->prossimo = Lista;
    Lista = tmp;
   inserisci('d', Lista);
   ptr listaTmp;
   listaTmp = Lista;
   while(listaTmp != NULL)
   {
      printf("carattere : %c \n",listaTmp->carattere);
      listaTmp = listaTmp->prossimo;
   }
   system("PAUSE");	
   return 0;
}

 typedef struct nodo *ptr;
IMHO questa gia' e' una pessima cosa, ti nasconde dal resto del codice
che stai usando un puntatore...
Ciao Jack

 migliaia di struct nodo).
Lo si può fare senza nascondere il fatto che è richiesto un puntatore.
Anzi sarebbe meglio evitarlo.
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   < 
http://giovanni.homelinux.net/
 >

 
salve a tutti
in pratica il prog che ho scritto non fa cio' che dovrebbe fare....
ovvero inserire nella lista un carattere in ordine alfabetico...
p.s. oggi ho provato a fare una cosa del genere senza lista, ho 
utilizzato un vettore, ho infilato dentro le lettere e con un algoritmo 
Insetion Sort l'ho ordinato.
magari provo ad applicarlo alla lista...sempre che non si possa fare 
senza algoritmo SORT...
grazie

 void inserisci(char c, ptr lis)
Questa funzione ï¿œ completamente sbagliata. Ci sono diversi errori 
concettuali e problemi con l'uso dei puntatori. Ecco come dovresti 
scriverla (non testata):
void inserisci(char c, ptr *lis) {
   while(*lis && (*lis)->carattere<c)
	lis=&((*lis)->prossimo);
   if (*lis && (*lis)->carattere==c) {
     printf("carattere gia' inserito\n");
   } else {
     ptr tmp=malloc(sizeof(listNodo));
     tmp->carattere=c;
     tmp->prossimo=(*lis);
     *lis=tmp;
   }
}
E.

 contenti :-)
tranne il tizio che dopo 6 mesi deve metterci le mani...
Ciao Jack

 ubriaca.
Ahhh allora è in questo modo che ti procuri il lavoro?
Ora so a chi non devo rivolgermi :-(



Normalmente esistono delle "specifiche tecniche" apposta.
Oltreutto, per procedere l'esempio di cui sopra con l'automobile, se
nessuna delle due opzioni è possibile si può sempre cambiare
macchina :) E' nell'interesse del produttore di macchine realizzare un
prodotto valido, altrimenti nessuno gliela comprerebbe. Per le
librerie magari è un po' più difficile, ma di certo è più veloce
cambiare lib e scrivere un wrapper, piuttosto che sistemare una
libreria che, in primo luogo, non avevamo avuto il tempo di scrivere.

 pare a te.
Allora: che il codice debba rispettare le specifiche e' il minimo
sindacale.
Poi si puo' scrivere codice "bello" e codice "brutto".
Il codice "bello" e' quello che e' facile aggiornare, modificare,
capire.
Quello "brutto" e' tutto il resto (comrpeso il codice super mega
efficiente).
Se il codice che scrivi lo usi solo tu puoi farlo un po' come ti pare
tanto chissenefrega, anche se ti sfido a rileggere del codice
incasinato 6 mesi dopo che l'hai scritto, specialmente se comincia a
trafficare coi puntatori.
Se invece lavori in un team e/o il codice presumibilmente lo va a
leggere qualcun altro allora scrivere codice bello e' quasi d'obbligo.
Ti invito a leggere le regole del MISRA C e questo link: 
http://www.spinroot.com/p10/
che si occupano di codice per Automotive e Safety Critical Code, ma
molte cose vanno benissimo ovunque.
Ciao Jack


La maggior parte dei consigli sono ottimi, ma focalizzati secondo me
sullo sviluppo su piattaforme embedded - una regola per tutte: "Do not
use dynamic memory allocation after initialization" è ottima per un
controllore, ma ridicola per un'applicazione interattiva.
Secondo me, come al solito, quello che conta è, al di là dei consigli
e dell'esperienza, il tempo a disposizione per completare un lavoro ;)

 un lavoro ;)
Posso garantirti per esperienza diretta che se scrivi del codice 
avendo ben chiare le regole di codifica lo scrivi, lo fai funzionare e 
lo integri in un sistema in meno tempo.



Non tutti siamo sempre così fortunati da decidere *quanto* tempo
avere. Se per farlo bene servono due settimane e per farlo funzionare
ne serve una, probabilmente il tempo a disposizione è di due giorni
(di cui qualche ora è da dedicare ai test). Se poi il codice non è più
modificabile, non è facile trovare bugs o aggiungere funzionalità ma
l'azienda è contenta allora non esistono problemi. Voglio dire... un
programmatore è più un muratore che un filosofo.
P.S. Non so se corrisponde a realtà, ma si diceva che fosse il
principale problema della scarsa qualità del software della Microsoft,
che di certo nel suo organico non ha gli ultimi arrivati!

Jack ha scritto:
 >...
Onestamente mi sento di dar ragione a Tetsuya. Se una libreria ha come 
compito quello di implementare un oggetto "lista", l'utente � meglio che 
non sappia che tale oggetto � in realt� un puntatore. Questo fa s� che 
l'utente sia forzato ad usare le funzioni fornite e non gli venga la 
malsana idea, per dirne una, di usare free() per liberare la memoria 
allocata dalla lista.
E.