Coda usando le matrici

Di seguito è la mia implementazione di una coda semplice utilizzando gli array.

#include #include #define QSIZE 5 //Limit size of queue to just 5 enteries /*Beginning of prototype for queue functions: Insert, retrieve and display*/ void qdisp(); //Display to queue array contents void qinsert(); //Insert a element into rear of queue int qdelete(); //Remove an element from front of queue /*End of prototyping*/ // Variables int fe=0,re=0,q[QSIZE],item; //fe(front entry), re(rear entry), q[](queue array), item(element to i/p or delete) void main() { int choice; while(1) { printf("1.Insert element\n2.Remove element\n3.Display element(s)\n4.Exit program\nEnter number for appropriate choice: "); scanf("%d",&choice); switch(choice) { case 1: printf("Enter value of element: "); scanf("%d",&item); qinsert(); break; case 2: item=qdelete(); printf("Removed \'%d\' from the queue\n",item); break; case 3: qdisp(); break; case 4: exit(0); /*case default : printf("Wrong choice i/p!"); break;*/ } } } //End of main, beginning for function definitons void qinsert() { if(re==QSIZE-1) { printf("Queue Overflow\n"); exit(0); } q[re]=item; re++; } int qdelete() { if(fe>re) { printf("Queue is empty!\n"); exit(0); } item=q[fe]; fe++; return item; } void qdisp() { int i; //i is loop counter variable if(fe>re) { printf("Queue is empty!\n"); exit(0); } printf("Queue items are: \n"); for(i=fe;i<=re;i++) printf("%d\n",q[i]); } 

Ho usato la voce iniziale anteriore e quella posteriore come 0 poiché inizialmente in una coda qualsiasi voce che per prima diventa l’ultima voce. Tuttavia il mio insegnante dice che dovrei mantenere la voce posteriore come “-1” e mentre si inserisce un elemento in coda, prima incrementare l’indice di entrata posteriore e quindi aggiungere il mio codice opposto di prima aggiunta e poi incrementale. Ho esaminato e online e fino ad ora non ho trovato il modo in cui ho sbagliato.

Fornisci informazioni se ho torto o è il mio insegnante?

Sia pre-incrementale che post-incrementale possono essere utilizzati in una coda. Ciò che cambia tuttavia sono le condizioni complete e vuote. Con pre-incremento la condizione completa è QSIZE-1 , con post-incremento la condizione completa è QSIZE . Con pre-incremento la condizione vuota è fe==re , con fe>re post-incremento.

L’utilizzo del pre-incremento può salvare una variabile temporanea in eliminazione. Si noti come è necessario salvare l’elemento corrente nell’elemento, quindi incrementare l’indice, quindi restituire l’elemento.

 item=q[fe]; fe++; return item; 

Puoi eliminare la variabile item incrementando l’indice, quindi restituendo l’elemento.

 fe++; return q[fe]; 

Ricorda, se si pre-incrementa l’inserimento, è necessario pre-incrementare per eliminare.

Ok, considera questo. Cosa succede fe e re sono entrambi QSIZE-1 ? La coda è vuota ma il tuo codice lo interpreterà come pieno (perché re==QSIZE-1 ).

Qualche insegnante in giro? Buono ok.

Gli insegnanti non hanno sempre ragione, ma probabilmente c’è una buona possibilità che tu lo abbia semplicemente frainteso. Finché capisci che quando fe == re la coda è vuota, sia inizialmente 0 sia va bene.

Tuttavia, alcune delle tue funzioni devono cambiare:

Elimina

 void qdisp(void) { int i; if(fe == re) // 1 { printf("Queue is empty!\n"); return; // 2 } printf("Queue items are:\n"); for(i = fe; i < re; i++) // 3 printf("%d\n", q[i]); } 
  1. == invece di >
  2. return invece di exit(0)
  3. < invece di <=

Inserire

 if(re == QSIZE) // 1 { printf("Queue Overflow\n"); return; // 2 } 
  1. QSIZE invece di QSIZE-1
  2. return invece di exit(0)

Elimina

Non c'è motivo di chiamare exit(0) . Nulla di fatale con il tentativo di eliminare da una coda vuota.

nella funzione di inserimento quando il primo a controllare la coda è vuoto o no la condizione è:

 if(r==0) 

perché quando la coda è vuota la parte posteriore è sempre a 0 .. quindi controlla che la coda di attesa abbia solo 1 elemento o più di 1 ..

 if(f==r-1) {f=0;r=0;} else {f++;} 

in inserimento funzione quando si inserisce l’ultimo elemento il posteriore si incrementa e si imposta su 5 quindi quando si cancella l’elemento anteriore viene incrementato e per l’ultimo elemento anteriore è 4 che è inferiore a quello posteriore di 1 … quindi condizione per verificare se è rimasto solo 1 elemento o no è f == r-1 e se è soddisfatto, la matrice diventa completamente vuota, quindi impostiamo il fronte e il retro su 0.