[C++] Costruzione coda

[Steven11]

Salve a tutti, mi trovavo ad osservare un programmino sulla costruzione di una lista che avesse la struttura di coda.

Nel codice che ora allego sostanzialmente non riesco a individuare il momento in cui l'elemento "coda" si attacchi a "coda1".
Immagino che il punto avviene quando dico

coda1=coda

Quindi significa che entrambi i puntatori contenuti nelle due strutture puntano allo stesso oggetto (che è nulla, se non sbaglio).
Dopodiché creo tutta la sequenza lavorando con coda1, e alla fine quando dico

coda=coda->prox;

sto attaccando.
Chiedo: è corretto quanto ho detto, e questa è effettivamente una coda a tutto gli effetti?
Grazie in anticipo per eventuali risposte

Il codice è il seguente.

# include<iostream>
struct ele {int info; ele *prox;};   
using namespace std;
void creacoda (ele *p);       
void stampacoda (ele *p);
main()
{
  ele *coda; ele *coda1;      
  coda=new ele;
  coda1=coda;
  creacoda (coda1);
  coda=coda->prox;    
  stampacoda (coda);
  
  system("PAUSE");
  return 0 ;
}
void creacoda (ele *p)  
{
  int x;
  cout << "\nDigitando zero si conclude la coda\n";
  cin >> x;
  while (x)
     {p->prox=new ele;
      p=p->prox;
      p->info=x;
      cin >> x;}
  p->prox=NULL;
}

Per completezza, la funzione di output

void stampacoda (ele *p)
{
  cout << "\n\nStampa coda\n";
  while (p)
    {cout << p->info << endl;
      p=p->prox;}
}

Ciao a tutti!

[Deckard1]

"Steven":
Chiedo: è corretto quanto ho detto, e questa è effettivamente una coda a tutto gli effetti?

No. Una struttura dati si definisce (oltre che sull'insieme di elementi in grado di memorizzare) con le operazioni che è possibile fare su di essa. Una coda per essere tale deve disporre di una funzione che permetta di inserire un elemento (enqueue), una funzione che restituisce il primo elemento della coda inserito (front) ed una che permetta di eliminare tale elemento (dequeue). Tutte queste tre funzioni devono lavorare generalmente in tempo costante.
Tu hai costruito una semplice lista nella quale inserisci una sequenza di elementi uno dopo l'altro cosicché l'ultimo elemento inserito sia posizionato in fondo alla lista. Però se dopo la chiamata a "creacoda" volessi inserire un nuovo elemento dovresti scandire per intero la lista, cosa assolutamente inefficiente.

[Steven11]

Ciao Deckard, grazie per l'intervento.

Nel frattempo ho costruito le funzioni che dicevi; penso in realtà di aver creato una cosa ben poco elegante (seppur funzionante), ho avuto dei problemi nell'utilizzo delle liste e i relativi puntatori quindi ho optato per la creazione di un intero $h$ che facesse da contatore durante l'immissione e rimanesse memorizzato, per scandire la stampa specialmente.

Sostanzialmente ho fatto in modo che alla fine del "creacoda" l'ultima cella puntasse ad una cella non specificata "t", che rimane vuota ma individuata (porre "t" uguale a NULL mi creava problemi, da cui la necessità di usare $h$: inizialmente infatti la stampa terminava da sola quando $p$ puntava a nulla).
Questa (cioè $t$) sarà poi chiamata da void enqueue per l'inserimento di un nuovo elemento senza dover ripassare per i dati già immessi.

Per quanto riguarda il "dequeue", ho semplicemente usato la funzione "delete" sulla prima cella, e ordinato che il puntatore di questa indicasse l'inizio della nuova coda. Torna anche con l'appunto che ho preso a lezione.

Non saprei tuttavia giudicare, non essendo incluso nel programma del corso, se le funzioni lavorino in tempo costante.

Grazie per eventuali osservazioni, il codice lo scrivo in basso. Ciao, grazie ancora

void creacoda (ele *p, ele *, ele *, int&);       
void enqueue (ele *t);
void stampacoda (ele *p, int&);
void cancel (ele *p, int);


main()
{
  ele *coda; ele *coda1; 
  coda=new ele;
  
  coda1=coda; ele*q; ele*t; t= new ele; int h=0;
  creacoda (coda1, q, t, h); 
  coda=coda->prox;    
  stampacoda (coda,h); 
  enqueue (t);
  h=h+1;
  stampacoda (coda,h);
  
  cancel (coda,h-1);
  
  system("PAUSE");
  return 0 ;
}
void creacoda (ele *p, ele *q, ele *t, int &h)  
{
  int x;
  int y;
  while (y)
     {
     p->prox=new ele;
      p=p->prox;
      cout<<"Numero:";cin >> x;
      p->info=x;
      cout<<"\nPremere 0 per smettere di inserire, un altro numero altrimenti";
      cin>>y; y=y; h++;}
 
  p->prox=t; 
  
}

void stampacoda (ele *p, int &h)
{
  cout << "\n\nStampa coda\n"; int l=h;
  while (l)
    {cout << p->info << endl;
      p=p->prox; l--;
      }
}

void enqueue (ele *t)
{
     
     int x; cout<<"\nAggiunta nuovo elemento:"; cin>>x;
     t->info=x;
     /*t->prox=NULL;*/
     return;
     }

void cancel (ele *p, int h)
{
     ele *q=p; delete q; cout<<"\nRimozione primo elemento coda\n"; p=p->prox;
     stampacoda (p,h); return;
     }

[edge1]

Steven immagino sei all'inizi,ma il tuo codice non mi piace.

Ti scrivo qualcosa io:

elem*p0;  
elem*fine;             //puntatore ma non creo nulla nel main ..
void crea()
{
            elem*p=new elem; 
            //iniz. valori
            p->prox=0;        //Tanto in fondo sicuro lo metto,sennò non è coda
                                    //Il puntatore fine è importante per non scorrere sempre la lista
            if (fine==0) { p0=p; fine=p0;}  //Se fine è 0 nn ci so elementi
           else{ fine->prox=p; fine=p;}   ((Altrimenti accodo e sposto puntatore
}
void cancella()
{          if (p0==0) return;
           //Cancello dalla testa
           elem*p=p0;
           p0=p0->prox;
           delete p;
}

          
           

Spero di essere stato di aiuto