queue data structure c with illustration
Una breve introduzione alla coda in C ++ con illustrazione.
La coda è una struttura dati di base proprio come uno stack. A differenza dello stack che utilizza l'approccio LIFO, queue utilizza l'approccio FIFO (first in, first out). Con questo approccio, il primo elemento che viene aggiunto alla coda è il primo elemento a essere rimosso dalla coda. Proprio come Stack, anche la coda è una struttura dati lineare.
applicazioni di java nel mondo reale
In un'analogia del mondo reale, possiamo immaginare una coda di autobus in cui i passeggeri aspettano l'autobus in una coda o in una fila. Il primo passeggero della fila entra per primo nell'autobus poiché il passeggero è quello che è arrivato per primo.
=> Leggi qui la popolare serie di formazione C ++.
Cosa imparerai:
Coda in C ++
In termini di software, la coda può essere visualizzata come un insieme o una raccolta di elementi come mostrato di seguito. Gli elementi sono disposti linearmente.
Abbiamo due estremità, cioè 'davanti' e 'dietro' alla coda. Quando la coda è vuota, entrambi i puntatori sono impostati su -1.
Il puntatore finale 'posteriore' è il punto da cui gli elementi vengono inseriti nella coda. L'operazione di aggiunta / inserimento di elementi nella coda è chiamata “enqueue”.
Il puntatore 'front-end' è il punto da cui gli elementi vengono rimossi dalla coda. L'operazione per rimuovere / eliminare elementi dalla coda è chiamata 'dequeue'.
Quando il valore del puntatore posteriore è size-1, diciamo che la coda è piena. Quando la parte anteriore è nulla, la coda è vuota.
Operazioni di base
La struttura dei dati della coda include le seguenti operazioni:
- Accodare: Aggiunge un elemento alla coda. L'aggiunta di un elemento alla coda viene sempre eseguita in fondo alla coda.
- DeQueue: Rimuove un elemento dalla coda. Un elemento viene rimosso o rimosso dalla coda sempre dalla parte anteriore della coda.
- è vuoto: Controlla se la coda è vuota.
- è pieno: Controlla se la coda è piena.
- sbirciare: Ottiene un elemento all'inizio della coda senza rimuoverlo.
Accodare
In questo processo, vengono eseguiti i seguenti passaggi:
- Controlla se la coda è piena.
- Se pieno, produce un errore di overflow ed esce.
- Altrimenti, incrementa 'posteriore'.
- Aggiungi un elemento alla posizione indicata da 'posteriore'.
- Restituisci il successo.
Dequeue
L'operazione di rimozione dalla coda consiste nei seguenti passaggi:
- Controlla se la coda è vuota.
- Se vuoto, visualizza un errore di underflow ed esce.
- Altrimenti, l'elemento di accesso è indicato da 'front'.
- Incrementa la 'parte anteriore' per puntare ai dati accessibili successivi.
- Restituisci il successo.
Successivamente, vedremo un'illustrazione dettagliata delle operazioni di inserimento ed eliminazione in coda.
Illustrazione
Questa è una coda vuota e quindi abbiamo retro e vuoto impostato su -1.
Successivamente, aggiungiamo 1 alla coda e, di conseguenza, il puntatore posteriore si sposta in avanti di una posizione.
Nella figura successiva, aggiungiamo l'elemento 2 alla coda spostando il puntatore posteriore in avanti di un altro incremento.
Nella figura seguente, aggiungiamo l'elemento 3 e spostiamo il puntatore posteriore di 1.
A questo punto, il puntatore posteriore ha valore 2 mentre il puntatore anteriore è sullo 0thPosizione.
Successivamente, cancelliamo l'elemento puntato dal puntatore anteriore. Poiché il puntatore anteriore è a 0, l'elemento che viene eliminato è 1.
Quindi il primo elemento inserito nella coda, cioè 1 sembra essere il primo elemento rimosso dalla coda. Di conseguenza, dopo la prima rimozione dalla coda, il puntatore anteriore verrà ora spostato in avanti fino alla posizione successiva che è 1.
Implementazione dell'array per la coda
Implementiamo la struttura dei dati della coda usando C ++.
#include #define MAX_SIZE 5 using namespace std; class Queue { private: int myqueue(MAX_SIZE), front, rear; public: Queue(){ front = -1; rear = -1; } boolisFull(){ if(front == 0 && rear == MAX_SIZE - 1){ return true; } return false; } boolisEmpty(){ if(front == -1) return true; else return false; } void enQueue(int value){ if(isFull()){ cout << endl<< 'Queue is full!!'; } else { if(front == -1) front = 0; rear++; myqueue(rear) = value; cout << value << ' '; } } int deQueue(){ int value; if(isEmpty()){ cout << 'Queue is empty!!' <= rear){ //only one element in queue front = -1; rear = -1; } else { front++; } cout << endl < ' << value << ' from myqueue'; return(value); } } /* Function to display elements of Queue */ void displayQueue() { int i; if(isEmpty()) { cout << endl << 'Queue is Empty!!' << endl; } else { cout << endl << 'Front = ' << front; cout << endl << 'Queue elements : '; for(i=front; i<=rear; i++) cout << myqueue(i) << ' '; cout << endl << 'Rear = ' << rear << endl; } } }; int main() { Queue myq; myq.deQueue(); //deQueue cout<<'Queue created:'< queue is full myq.enQueue(60); myq.displayQueue(); //deQueue =>removes 10 myq.deQueue(); //queue after dequeue myq.displayQueue(); return 0; }
Produzione:
La coda è vuota !!
Coda creata:
10 20 30 40 50
La coda è piena !!
Anteriore = 0
Elementi della coda: 10 20 30 40 50
Posteriore = 4
Eliminato => 10 da myqueue
Anteriore = 1
Elementi della coda: 20 30 40 50
Posteriore = 4
L'implementazione precedente mostra la coda rappresentata come un array. Specifichiamo max_size per l'array. Definiamo anche le operazioni di accodamento e rimozione dalla coda, nonché le operazioni isFull e isEmpty.
Di seguito è riportata l'implementazione Java della struttura dati della coda.
// A class representing a queue class Queue { int front, rear, size; int max_size; int myqueue(); public Queue(int max_size) { this.max_size = max_size; front = this.size = 0; rear = max_size - 1; myqueue = new int(this.max_size); } //if size = max_size , queue is full boolean isFull(Queue queue) { return (queue.size == queue.max_size); } // size = 0, queue is empty boolean isEmpty(Queue queue) { return (queue.size == 0); } // enqueue - add an element to the queue void enqueue( int item) { if (isFull(this)) return; this.rear = (this.rear + 1)%this.max_size; this.myqueue(this.rear) = item; this.size = this.size + 1; System.out.print(item + ' ' ); } // dequeue - remove an elment from the queue int dequeue() { if (isEmpty(this)) return Integer.MIN_VALUE; int item = this.myqueue(this.front); this.front = (this.front + 1)%this.max_size; this.size = this.size - 1; return item; } // move to front of the queue int front() { if (isEmpty(this)) return Integer.MIN_VALUE; return this.myqueue(this.front); } // move to the rear of the queue int rear() { if (isEmpty(this)) return Integer.MIN_VALUE; return this.myqueue(this.rear); } } // main class class Main { public static void main(String() args) { Queue queue = new Queue(1000); System.out.println('Queue created as:'); queue.enqueue(10); queue.enqueue(20); queue.enqueue(30); queue.enqueue(40); System.out.println('
Element ' + queue.dequeue() + ' dequeued from queue
'); System.out.println('Front item is ' + queue.front()); System.out.println('Rear item is ' + queue.rear()); } }
Produzione:
Coda creata come:
10 20 30 40
Elemento 10 rimosso dalla coda
L'articolo anteriore è 20
L'articolo posteriore è 40
L'implementazione sopra è simile all'implementazione C ++.
Successivamente, implementiamo la coda in C ++ utilizzando un elenco collegato.
Implementazione dell'elenco collegato per la coda:
#include using namespace std; struct node { int data; struct node *next; }; struct node* front = NULL; struct node* rear = NULL; struct node* temp; void Insert(int val) { if (rear == NULL) { rear = new node; rear->next = NULL; rear->data = val; front = rear; } else { temp=new node; rear->next = temp; temp->data = val; temp->next = NULL; rear = temp; } } void Delete() { temp = front; if (front == NULL) { cout<<'Queue is empty!!'next; cout<<'Element deleted from queue is : ' Produzione:
Coda creata:
10 20 30 40 50
L'elemento eliminato dalla coda è: 10
Coda dopo un'eliminazione:
20 30 40 50
app per scaricare musica mp3 per Android
Stack vs. Coda
Le pile e le code sono strutture dati secondarie che possono essere utilizzate per memorizzare i dati. Possono essere programmati utilizzando le strutture dati primarie come array ed elenchi collegati. Dopo aver discusso in dettaglio entrambe le strutture di dati, è tempo di discutere le principali differenze tra queste due strutture di dati.
Pile Code Utilizza l'approccio LIFO (Last in, First out). Utilizza l'approccio FIFO (First in, First out). Gli elementi vengono aggiunti o eliminati da una sola estremità chiamata 'Top' dello stack. Gli elementi vengono aggiunti dall'estremità 'posteriore' della coda e vengono rimossi dalla 'parte anteriore' della coda. Le operazioni di base per lo stack sono 'push' e 'pop'. Le operazioni di base per una coda sono 'enqueue' e 'dequeue'. Possiamo fare tutte le operazioni sullo stack mantenendo un solo puntatore per accedere alla cima dello stack. Nelle code, dobbiamo mantenere due puntatori, uno per accedere alla parte anteriore della coda e il secondo per accedere alla parte posteriore della coda. Lo stack viene utilizzato principalmente per risolvere problemi ricorsivi. Le code vengono utilizzate per risolvere i problemi relativi all'elaborazione ordinata.
Applicazioni di coda
Discutiamo di seguito le varie applicazioni della struttura dei dati delle code.
- La struttura dei dati della coda viene utilizzata in varie pianificazioni di CPU e dischi. Qui abbiamo più attività che richiedono CPU o disco allo stesso tempo. Il tempo della CPU o del disco è pianificato per ogni attività utilizzando una coda.
- La coda può essere utilizzata anche per lo spooling di stampa in cui il numero di lavori di stampa viene inserito in una coda.
- La gestione degli interrupt nei sistemi in tempo reale viene eseguita utilizzando una struttura dati a coda. Le interruzioni vengono gestite nell'ordine in cui arrivano.
- La ricerca in ampiezza in cui vengono attraversati i nodi adiacenti di un albero prima di passare al livello successivo utilizza una coda per l'implementazione.
- I sistemi telefonici dei call center utilizzano le code per trattenere le chiamate fino a quando non ricevono risposta dai rappresentanti del servizio.
In generale, possiamo dire che la struttura dei dati della coda viene utilizzata ogni volta che richiediamo che le risorse o gli elementi vengano serviti nell'ordine in cui arrivano, ovvero First in, First Out.
Conclusione
La coda è una struttura dati FIFO (First In, First Out) utilizzata principalmente nelle risorse in cui è richiesta la pianificazione. Ha due puntatori posteriori e anteriori alle due estremità e questi sono usati rispettivamente per inserire un elemento e rimuovere un elemento dalla / alla coda.
Nel nostro prossimo tutorial, impareremo alcune delle estensioni della coda come la coda prioritaria e la coda circolare.
=> Vedi qui per esplorare l'elenco completo dei tutorial C ++.
Lettura consigliata
- Priorità Struttura Dati Coda In C ++ Con Illustrazione
- Coda prioritaria in AWL
- Stack Struttura Dati In C ++ Con Illustrazione
- Struttura Dati Elenco Collegato Circolare In C ++ Con Illustrazione
- Struttura Dati Elenco Collegato In C ++ Con Illustrazione
- Struttura dei dati della lista doppiamente collegata in C ++ con illustrazione
- Introduzione alle strutture dati in C ++
- Parametrizzazione dei dati JMeter mediante variabili definite dall'utente