queue data structure c with illustration
Uma breve introdução à fila em C ++ com ilustração.
A fila é uma estrutura de dados básica como uma pilha. Em contraste com a pilha que usa a abordagem LIFO, a fila usa a abordagem FIFO (primeiro a entrar, primeiro a sair). Com essa abordagem, o primeiro item adicionado à fila é o primeiro item a ser removido da fila. Assim como Stack, a fila também é uma estrutura de dados linear.
principais empresas de desenvolvimento web na índia
Em uma analogia com o mundo real, podemos imaginar uma fila de ônibus onde os passageiros esperam pelo ônibus em uma fila ou fila. O primeiro passageiro da fila entra no ônibus primeiro, pois esse passageiro é o que veio primeiro.
=> Leia a popular série de treinamento C ++ aqui.
O que você aprenderá:
Fila em C ++
Em termos de software, a fila pode ser vista como um conjunto ou coleção de elementos conforme mostrado abaixo. Os elementos são organizados linearmente.
Temos duas extremidades, ou seja, 'frente' e 'traseira' da fila. Quando a fila está vazia, os dois ponteiros são definidos como -1.
O ponteiro da extremidade “traseira” é o local de onde os elementos são inseridos na fila. A operação de adicionar / inserir elementos na fila é denominada “enfileirar”.
O ponteiro “frontal” é o local de onde os elementos são removidos da fila. A operação para remover / excluir elementos da fila é chamada de “desenfileirar”.
Quando o valor do ponteiro traseiro é tamanho-1, dizemos que a fila está cheia. Quando a frente é nula, a fila está vazia.
Operações básicas
A estrutura de dados da fila inclui as seguintes operações:
- EnQueue: Adiciona um item à fila. A adição de um item à fila é sempre feita na parte traseira da fila.
- DeQueue: Remove um item da fila. Um item é removido ou retirado da fila sempre da frente da fila.
- está vazia: Verifica se a fila está vazia.
- está cheio: Verifica se a fila está cheia.
- olhadinha: Obtém um elemento na frente da fila sem removê-lo.
Enqueue
Neste processo, as seguintes etapas são realizadas:
- Verifique se a fila está cheia.
- Se estiver cheio, produz um erro de estouro e sai.
- Caso contrário, aumente 'traseiro'.
- Adicione um elemento ao local apontado por ‘traseiro’.
- Retorno com sucesso.
Dequeue
A operação de desenfileiramento consiste nas seguintes etapas:
- Verifique se a fila está vazia.
- Se estiver vazio, exibe um erro de underflow e sai.
- Caso contrário, o elemento de acesso é apontado por 'frente'.
- Incremente a 'frente' para apontar para os próximos dados acessíveis.
- Retorno com sucesso.
A seguir, veremos uma ilustração detalhada das operações de inserção e exclusão na fila.
Ilustração
Esta é uma fila vazia e, portanto, temos rear e empty definidos como -1.
Em seguida, adicionamos 1 à fila e, como resultado, o ponteiro traseiro avança em um local.
Na próxima figura, adicionamos o elemento 2 à fila movendo o ponteiro traseiro para frente em outro incremento.
Na figura a seguir, adicionamos o elemento 3 e movemos o ponteiro traseiro em 1.
Neste ponto, o ponteiro traseiro tem valor 2, enquanto o ponteiro frontal está em 0ºlocalização.
Em seguida, excluímos o elemento apontado pelo ponteiro frontal. Como o ponteiro frontal está em 0, o elemento que é excluído é 1.
Assim, o primeiro elemento inserido na fila, ou seja, 1 passa a ser o primeiro elemento removido da fila. Como resultado, após o primeiro desenfileiramento, o ponteiro frontal agora será movido para a frente para o próximo local que é 1.
Implementação de array para fila
Vamos implementar a estrutura de dados da fila 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; }Resultado:
A fila está vazia !!
Fila criada:
10 20 30 40 50
A fila está cheia !!
Frente = 0
Elementos da fila: 10 20 30 40 50
Traseira = 4
Excluído => 10 da minha fila
Frente = 1
Elementos da fila: 20 30 40 50
Traseira = 4
A implementação acima mostra a fila representada como uma matriz. Especificamos o max_size para o array. Também definimos as operações de enfileiramento e desenfileiramento, bem como as operações isFull e isEmpty.
A seguir, é fornecida a implementação Java da estrutura de dados da fila.
// 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()); } } Resultado:
Fila criada como:
10 20 30 40
Elemento 10 retirado da fila
O item da frente é 20
O item traseiro é 40
A implementação acima é semelhante à implementação C ++.
A seguir, vamos implementar a fila em C ++ usando uma lista vinculada.
Implementação de lista vinculada para fila:
#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 : ' Resultado:
Fila criada:
10 20 30 40 50
O elemento excluído da fila é: 10
Fila após uma exclusão:
20 30 40 50
melhor lugar para assistir anime de graça
Stack vs. Fila
Pilhas e filas são estruturas de dados secundárias que podem ser usadas para armazenar dados. Eles podem ser programados usando as estruturas de dados primárias, como matrizes e listas vinculadas. Tendo discutido ambas as estruturas de dados em detalhes, é hora de discutir as principais diferenças entre essas duas estruturas de dados.
Pilhas Filas Usa a abordagem LIFO (último a entrar, primeiro a sair). Usa abordagem FIFO (primeiro a entrar, primeiro a sair). Os itens são adicionados ou excluídos de apenas uma extremidade chamada “Topo” da pilha. Os itens são adicionados da extremidade “traseira” da fila e são removidos da “frente” da fila. As operações básicas para a pilha são “empurrar” e “estalar”. As operações básicas para uma fila são “enfileirar” e “retirar da fila”. Podemos fazer todas as operações na pilha mantendo apenas um ponteiro para acessar o topo da pilha. Em filas, precisamos manter dois ponteiros, um para acessar a frente da fila e o segundo para acessar a parte traseira da fila. A pilha é usada principalmente para resolver problemas recursivos. As filas são usadas para resolver problemas relacionados ao processamento solicitado.
Aplicações de fila
Vamos discutir as várias aplicações da estrutura de dados da fila abaixo.
- A estrutura de dados da fila é usada em vários escalonamentos de CPU e disco. Aqui, temos várias tarefas que requerem CPU ou disco ao mesmo tempo. O tempo de CPU ou disco é agendado para cada tarefa usando uma fila.
- A fila também pode ser usada para spool de impressão, em que o número de trabalhos de impressão é colocado em uma fila.
- O tratamento de interrupções em sistemas de tempo real é feito usando uma estrutura de dados de fila. As interrupções são tratadas na ordem em que chegam.
- A pesquisa em amplitude na qual os nós vizinhos de uma árvore são percorridos antes de passar para o próximo nível usa uma fila para implementação.
- Os sistemas de telefonia do call center usam filas para reter as chamadas até que sejam atendidas pelos representantes de serviço.
Em geral, podemos dizer que a estrutura de dados da fila é usada sempre que exigimos que os recursos ou itens sejam atendidos na ordem em que chegam, ou seja, primeiro a entrar, primeiro a sair.
Conclusão
A fila é uma estrutura de dados FIFO (First In, First Out) usada principalmente em recursos onde o agendamento é necessário. Ele tem dois ponteiros traseiros e dianteiros em duas extremidades e são usados para inserir um elemento e remover um elemento de / para a fila, respectivamente.
Em nosso próximo tutorial, aprenderemos sobre algumas das extensões da fila, como fila de prioridade e fila circular.
=> Veja aqui para explorar a lista completa de tutoriais C ++.
Leitura recomendada
- Estrutura de dados da fila de prioridade em C ++ com ilustração
- Fila prioritária em STL
- Estrutura de pilha de dados em C ++ com ilustração
- Estrutura de dados de lista vinculada circular em C ++ com ilustração
- Estrutura de dados de lista vinculada em C ++ com ilustração
- Estrutura de dados de lista duplamente vinculada em C ++ com ilustração
- Introdução às estruturas de dados em C ++
- Parametrização de dados JMeter usando variáveis definidas pelo usuário