DOMANDA eliminare primo elemento in coda........

Pubblicità
M

marcococ

Nuovo Utente
Messaggi
29
Reazioni
1
Punteggio
21
salve ragazzi...sto cercando di capire le liste ma mi sembrano un argomento molto ostico perciò chiedo a voi .......ho questo codice ....con una struct e la funzione per la creazione di una lista........quello che devo fare è creare la "classica" funzione che elimini il primo elemento in testa della lista ........come posso fare?
Codice: 
struct Piano {
  unsigned short numero_piano;
  struct Piano *prossimo_piano;
}Piano;


struct Piano *crea_listaNinja() {
  struct Piano *p, *punt; int i, n,x=1;
  n=Ninja.zaino[materiale];
  if(n==0) { p = NULL; //
  } else { /* creazione primo elemento */
  p = (struct Piano *)malloc(sizeof(struct Piano));
  p->numero_piano=Ninja.zaino[materiale];
  punt = p;
  /* creazione elementi successivi */
        for(i=1; i<n; i++)
        {
           punt->prossimo_piano = (struct Piano *)malloc(sizeof(struct Piano));
           punt = punt->prossimo_piano;
           punt->numero_piano=Ninja.zaino[materiale]-x ;
           ++x;
        } // chiudo il for
        punt->prossimo_piano = NULL; // marcatore fine lista
     } // chiudo l’if-else
     return(p);}
 
marcococ ha detto:
salve ragazzi...sto cercando di capire le liste ma mi sembrano un argomento molto ostico perciò chiedo a voi .......ho questo codice ....con una struct e la funzione per la creazione di una lista........quello che devo fare è creare la "classica" funzione che elimini il primo elemento in testa della lista ........come posso fare?
Codice: 
struct Piano {
  unsigned short numero_piano;
  struct Piano *prossimo_piano;
}Piano;


struct Piano *crea_listaNinja() {
  struct Piano *p, *punt; int i, n,x=1;
  n=Ninja.zaino[materiale];
  if(n==0) { p = NULL; //
  } else { /* creazione primo elemento */
  p = (struct Piano *)malloc(sizeof(struct Piano));
  p->numero_piano=Ninja.zaino[materiale];
  punt = p;
  /* creazione elementi successivi */
        for(i=1; i<n; i++)
        {
           punt->prossimo_piano = (struct Piano *)malloc(sizeof(struct Piano));
           punt = punt->prossimo_piano;
           punt->numero_piano=Ninja.zaino[materiale]-x ;
           ++x;
        } // chiudo il for
        punt->prossimo_piano = NULL; // marcatore fine lista
     } // chiudo l’if-else
     return(p);}
Clicca per espandere...

Ma n=Ninja.zaino[materiale] cos'è?
 
lì accedo ad un'array messo in una struct ....perchè in base al numero "n" di "materiale" costruisco una torre con "n" piani
 
Ragionala così, il tuo scopo è quello di andare a cancellare la testa della lista, quindi ciò che dovresti fare è andare a crearti una copia della lista Piano, far puntare la testa della lista all'elemento successivo e liberare lo spazio di memoria allocato dalla copia della lista.
Prova a seguire le mie indicazione e a provare a scrivere qualcosa, vediamo cosa ne esce!
 
Ci hai postato il codice che crea la lista, ma quello e' inessenziale per il problema che hai chiesto, ossia eliminare il primo elemento di una lista, che e' indipendente da come sia definita la lista e come sia stata creata.
La lista viene accessa semplicemente come il puntatore del primo elemento. Poiche' tu devi eliminare proprio quello, devi per forza di cosa alterare quello, che puntera' quindi al secondo elemento, poi devi deallocare la memoria del primo. Segui i suggerimenti di @Davo23
 
una roba così può andar bene ?....
Codice: 
void eliminatesta_listaNinja(struct Piano *p){

struct Piano *temp=p->prossimo_piano;

  free(p);
  p=temp;
   }
 
Non chiederlo a noi, prova e guarda se funziona :)

L'idea e' quella, ma non funziona in quanto la funzione deve tornare il nuovo valore della testa della lista. Cosi' come e' i cambiamenti rimangono locali alla funzione.
 
marcococ ha detto:
salve ragazzi...sto cercando di capire le liste ma mi sembrano un argomento molto ostico perciò chiedo a voi .......ho questo codice ....con una struct e la funzione per la creazione di una lista........quello che devo fare è creare la "classica" funzione che elimini il primo elemento in testa della lista ........come posso fare?
Codice: 
struct Piano {
  unsigned short numero_piano;
  struct Piano *prossimo_piano;
}Piano;


struct Piano *crea_listaNinja() {
  struct Piano *p, *punt; int i, n,x=1;
  n=Ninja.zaino[materiale];
  if(n==0) { p = NULL; //
  } else { /* creazione primo elemento */
  p = (struct Piano *)malloc(sizeof(struct Piano));
  p->numero_piano=Ninja.zaino[materiale];
  punt = p;
  /* creazione elementi successivi */
        for(i=1; i<n; i++)
        {
           punt->prossimo_piano = (struct Piano *)malloc(sizeof(struct Piano));
           punt = punt->prossimo_piano;
           punt->numero_piano=Ninja.zaino[materiale]-x ;
           ++x;
        } // chiudo il for
        punt->prossimo_piano = NULL; // marcatore fine lista
     } // chiudo l’if-else
     return(p);}
Clicca per espandere...

In testa o in coda ? :look:
L'intestazione del thread parla di cancellazione in coda, il testo invece parla di cancellazione in testa :skept:
 
Stiamo dunque parlando di strutture dinamiche semplici (pile, code, ecc.) o, per meglio dire, "concatenate", in contrapposizione alle strutture statiche e sequenziali dei vettori (array), delle matrici e dei record :sisi:
La struttura dinamica più semplice da gestire è la lista "semplice" ;)
Ciascun elemento della lista è un record costituito da almeno due campi (possono esserci più campi informativi ma il meccanismo non cambia), uno per l'informazione e uno per il puntatore.
L'indirizzo del primo elemento viene memorizzato nel puntatore di testa e l'unico modo per accedere alla struttura è tramite il puntatore di testa.
Ora, per quanto riguarda la cancellazione di un elemento da una lista, essenzialmente si tratta di una cancellazione logica, l'elemento viene semplicemente "sganciato" e reso inaccessibile ma le aree di memoria che lo contengono non vengono liberate "automaticamente" :D
Come spiegato da @Davo23, per la cancellazione in testa, supponendo che l'elemento da sganciare sia il primo della lista, è sufficiente aggiornare il puntatore di testa in modo che il successore del primo elemento diventi il nuovo primo elemento :asd:
Non c'è invece alcuna differenza tra la cancellazione in mezzo e in coda, in entrambi i casi occorre conoscere l'indirizzo dell'elemento precedente a quello da sganciare ;)

P.S. Nel formalismo Pascal-like un oggetto il cui indirizzo è memorizzato in un puntatore si indica in questo modo: puntatore^ (simbolo di elevamento a potenza come indice della variabile puntatore) :sisi:
Quindi se il primo elemento da sganciare contiene, ad esempio, l'informazione 'X', cioè se p0^.inf='X' (p0 è il puntatore di testa, inf è il campo informazione), la cancellazione avverrà nel seguente modo: p0 <-- p0^.pun (pun è il campo puntatore), sempre utilizzando un formalismo Pascal-like :asd:
 
Pubblicità
Pubblicità
Indietro
Top