queue data structure c with illustration
Une brève introduction à la file d'attente en C ++ avec illustration.
La file d'attente est une structure de données de base, tout comme une pile. Contrairement à la pile qui utilise l'approche LIFO, la file d'attente utilise l'approche FIFO (premier entré, premier sorti). Avec cette approche, le premier élément ajouté à la file d'attente est le premier élément à être supprimé de la file d'attente. Tout comme Stack, la file d'attente est également une structure de données linéaire.
application qui vous permet d'espionner un autre téléphone
Dans une analogie du monde réel, on peut imaginer une file d'attente de bus où les passagers attendent le bus dans une file d'attente ou une ligne. Le premier passager de la file entre en premier dans le bus car il se trouve que ce passager est celui qui est arrivé en premier.
=> Lisez la série de formations populaires C ++ ici.
Ce que vous apprendrez:
File d'attente en C ++
En termes logiciels, la file d'attente peut être considérée comme un ensemble ou une collection d'éléments, comme illustré ci-dessous. Les éléments sont disposés linéairement.
Nous avons deux extrémités, à savoir «avant» et «arrière» de la file d'attente. Lorsque la file d'attente est vide, les deux pointeurs sont définis sur -1.
Le pointeur d'extrémité «arrière» est l'endroit à partir duquel les éléments sont insérés dans la file d'attente. L'opération d'ajout / d'insertion d'éléments dans la file d'attente est appelée «mise en file d'attente».
Le pointeur d'extrémité «avant» est l'endroit d'où les éléments sont supprimés de la file d'attente. L'opération pour supprimer / supprimer des éléments de la file d'attente est appelée «dequeue».
Lorsque la valeur du pointeur arrière est size-1, nous disons que la file d'attente est pleine. Lorsque le front est nul, la file d'attente est vide.
Opérations de base
La structure des données de la file d'attente comprend les opérations suivantes:
- EnQueue: Ajoute un élément à la file d'attente. L'ajout d'un élément à la file d'attente se fait toujours à l'arrière de la file d'attente.
- DeQueue: Supprime un élément de la file d'attente. Un élément est toujours supprimé ou retiré de la file d'attente depuis le début de la file d'attente.
- est vide: Vérifie si la file d'attente est vide.
- est rempli: Vérifie si la file d'attente est pleine.
- coup d'oeil: Obtient un élément au début de la file d'attente sans le supprimer.
Mettre en file d'attente
Dans ce processus, les étapes suivantes sont effectuées:
- Vérifiez si la file d'attente est pleine.
- S'il est plein, génère une erreur de débordement et quitte.
- Sinon, incrémenter «arrière».
- Ajoutez un élément à l'emplacement indiqué par «arrière».
- Retournez le succès.
Retirer la file d'attente
L'opération de retrait de la file d'attente comprend les étapes suivantes:
- Vérifiez si la file d'attente est vide.
- S'il est vide, affichez une erreur de dépassement inférieur et quittez.
- Sinon, l’élément d’accès est signalé par «front».
- Incrémentez le «front» pour pointer vers les prochaines données accessibles.
- Retournez le succès.
Ensuite, nous verrons une illustration détaillée des opérations d'insertion et de suppression dans la file d'attente.
Illustration
Il s'agit d'une file d'attente vide et nous avons donc arrière et vide mis à -1.
Ensuite, nous ajoutons 1 à la file d'attente et, par conséquent, le pointeur arrière avance d'un emplacement.
Dans la figure suivante, nous ajoutons l'élément 2 à la file d'attente en déplaçant le pointeur arrière d'un autre incrément vers l'avant.
Dans la figure suivante, nous ajoutons l'élément 3 et déplaçons le pointeur arrière de 1.
À ce stade, le pointeur arrière a la valeur 2 tandis que le pointeur avant est à 0elieu.
Ensuite, nous supprimons l'élément pointé par le pointeur avant. Comme le pointeur avant est à 0, l'élément qui est supprimé est 1.
Ainsi, le premier élément entré dans la file d'attente, c'est-à-dire 1, se trouve être le premier élément retiré de la file d'attente. En conséquence, après la première sortie de la file d'attente, le pointeur avant sera maintenant déplacé vers le prochain emplacement qui est 1.
Implémentation de baie pour la file d’attente
Implémentons la structure de données de file d'attente en utilisant 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; }Production:
La file d'attente est vide !!
File d'attente créée:
10 20 30 40 50
La file d'attente est pleine !!
Avant = 0
Éléments de file d'attente: 10 20 30 40 50
Arrière = 4
Supprimé => 10 de ma file d'attente
Avant = 1
Éléments de file d'attente: 20 30 40 50
Arrière = 4
L'implémentation ci-dessus montre la file d'attente représentée sous forme de tableau. Nous spécifions le max_size pour le tableau. Nous définissons également les opérations de mise en file d'attente et de retrait de la file d'attente ainsi que les opérations isFull et isEmpty.
Vous trouverez ci-dessous l'implémentation Java de la structure de données de la file d'attente.
// 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()); } } Production:
File d'attente créée comme:
10 20 30 40
Élément 10 retiré de la file d'attente
L'article avant est 20
L'article arrière est 40
L'implémentation ci-dessus est similaire à l'implémentation C ++.
Ensuite, implémentons la file d'attente en C ++ en utilisant une liste chaînée.
Implémentation de liste liée pour la file d'attente:
#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 : ' Production:
File d'attente créée:
10 20 30 40 50
L'élément supprimé de la file d'attente est: 10
File d'attente après une suppression:
20 30 40 50
où est la clé de sécurité du réseau
Pile Vs. File d'attente
Les piles et les files d'attente sont des structures de données secondaires qui peuvent être utilisées pour stocker des données. Ils peuvent être programmés en utilisant les structures de données primaires telles que les tableaux et les listes liées. Après avoir examiné les deux structures de données en détail, il est temps de discuter des principales différences entre ces deux structures de données.
Piles Files d'attente Utilise l'approche LIFO (dernier entré, premier sorti). Utilise l'approche FIFO (premier entré, premier sorti). Les éléments sont ajoutés ou supprimés à une seule extrémité appelée «Haut» de la pile. Les éléments sont ajoutés à partir de l'extrémité «arrière» de la file d'attente et sont supprimés de «l'avant» de la file d'attente. Les opérations de base pour la pile sont «push» et «pop». Les opérations de base pour une file d'attente sont «mettre en file d'attente» et «retirer la file d'attente». Nous pouvons effectuer toutes les opérations sur la pile en ne conservant qu'un seul pointeur pour accéder au sommet de la pile. Dans les files d'attente, nous devons maintenir deux pointeurs, l'un pour accéder à l'avant de la file d'attente et le second pour accéder à l'arrière de la file d'attente. La pile est principalement utilisée pour résoudre des problèmes récursifs. Les files d'attente sont utilisées pour résoudre les problèmes liés au traitement ordonné.
Applications de file d'attente
Voyons ci-dessous les différentes applications de la structure de données de file d'attente.
- La structure des données de file d'attente est utilisée dans diverses ordonnancements de CPU et de disque. Ici, nous avons plusieurs tâches nécessitant un processeur ou un disque en même temps. L'heure du processeur ou du disque est planifiée pour chaque tâche à l'aide d'une file d'attente.
- La file d'attente peut également être utilisée pour la mise en file d'attente d'impression dans laquelle le nombre de travaux d'impression est placé dans une file d'attente.
- La gestion des interruptions dans les systèmes en temps réel est effectuée à l'aide d'une structure de données de file d'attente. Les interruptions sont traitées dans l'ordre où elles arrivent.
- La recherche en largeur d'abord dans laquelle les nœuds voisins d'un arbre sont traversés avant de passer au niveau suivant utilise une file d'attente pour l'implémentation.
- Les systèmes téléphoniques des centres d'appels utilisent des files d'attente pour mettre les appels en attente jusqu'à ce que les représentants de service y répondent.
En général, nous pouvons dire que la structure de données de la file d'attente est utilisée chaque fois que nous avons besoin que les ressources ou les éléments soient traités dans l'ordre où ils arrivent, c'est-à-dire premier entré, premier sorti.
Conclusion
La file d'attente est une structure de données FIFO (premier entré, premier sorti) qui est principalement utilisée dans les ressources où la planification est requise. Il a deux pointeurs arrière et avant à deux extrémités et ceux-ci sont utilisés pour insérer un élément et retirer un élément vers / de la file d'attente respectivement.
Dans notre prochain didacticiel, nous découvrirons certaines des extensions de la file d'attente comme la file d'attente prioritaire et la file d'attente circulaire.
=> Voir ici pour explorer la liste complète des didacticiels C ++.
lecture recommandée
- Structure de données de file d'attente prioritaire en C ++ avec illustration
- File d'attente prioritaire dans STL
- Empiler la structure de données en C ++ avec illustration
- Structure de données de liste liée circulaire en C ++ avec illustration
- Structure de données de liste liée en C ++ avec illustration
- Structure de données de liste doublement liée en C ++ avec illustration
- Introduction aux structures de données en C ++
- Paramétrage des données JMeter à l'aide de variables définies par l'utilisateur