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

[marcococ]

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?

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);}

 

[Dawking]

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?

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);}

Ma n=Ninja.zaino[materiale] cos'è?

 

[marcococ]

lì accedo ad un'array messo in una struct ....perchè in base al numero "n" di "materiale" costruisco una torre con "n" piani

 

[Dawking]

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!

 

[Andretti60]

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

 

[marcococ]

una roba così può andar bene ?....

void eliminatesta_listaNinja(struct Piano *p){

struct Piano *temp=p->prossimo_piano;

  free(p);
  p=temp;
   }

 

[Andretti60]

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.

 

[Utente 16812]

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?

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);}

In testa o in coda ? :look:
L'intestazione del thread parla di cancellazione in coda, il testo invece parla di cancellazione in testa :skept:

 

[Dawking]

In testa o in coda ? :look:
L'intestazione del thread parla di cancellazione in coda, il testo invece parla di cancellazione in testa :skept:

Penso si riferisca al primo elemento in testa della lista :sisi:

 

[Utente 16812]

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: