TechCodeview

Uma fila é outro tipo de estrutura de dados linear usada para armazenar elementos como qualquer outra estrutura de dados, mas de uma maneira específica. Em palavras simples, podemos dizer que a fila é um tipo de estrutura de dados na linguagem de programação Java que armazena elementos do mesmo tipo. Os componentes em uma fila são armazenados em um comportamento FIFO (First In, First Out). Existem duas extremidades na coleção da fila, ou seja, frontal e traseira. A fila tem duas extremidades: frontal e traseira.

A figura a seguir descreve perfeitamente a propriedade FIFO (First In, First Out) da fila Java.

Conforme explicado na imagem anterior, podemos ver que a fila é uma estrutura de dados linear com dois terminais, ou seja, início (frontal) e fim (traseiro). Os componentes são adicionados dentro da fila no final da fila e os componentes são extraídos do front-end da fila.

A Fila é uma interface no Java que pertence ao pacote Java.util. Ele também estende a interface da Coleção.

A representação genérica da interface Java Queue é mostrada abaixo:

fazer loop while java

 public interface Queue extends Collection 

Como discutimos acima, a Fila é uma interface, portanto também podemos dizer que a fila não pode ser instanciada porque as interfaces não podem ser instanciadas. Se um usuário deseja implementar a funcionalidade da interface Queue em Java, então é obrigatório ter algumas classes sólidas que implementem a interface Queue.

Na linguagem de programação Java, existem duas classes diferentes que são usadas para implementar a interface Queue. Essas aulas são:

10 milhões

• Lista vinculada
• Fila de prioridade

Características da fila Java

O Java Queue pode ser considerado uma das estruturas de dados mais importantes no mundo da programação. Java Queue é atraente por causa de suas propriedades. As propriedades significativas da estrutura de dados Java Queue são fornecidas a seguir:

• Java Queue obedece ao modo FIFO (First In, First Out). Indica que os elementos são inseridos na fila no final e eliminados pela frente.
• A interface Java Queue fornece todas as regras e processos da interface Collection, como inclusão, exclusão, etc.
• Existem duas classes diferentes usadas para implementar a interface Queue. Essas classes são LinkedList e PriorityQueue.
• Além desses dois, existe uma classe que é Array Blocking Queue, que é usada para implementar a interface Queue.
• Existem dois tipos de filas, filas ilimitadas e filas limitadas. As filas que fazem parte do pacote java.util são conhecidas como filas ilimitadas e as filas limitadas são as filas que estão presentes no pacote java.util.concurrent.
• A Deque ou (fila dupla) também é um tipo de fila que realiza a inclusão e exclusão de elementos de ambas as extremidades.
• O deque também é considerado thread-safe.
• As filas de bloqueio também são um dos tipos de filas que também são thread-safe. As Filas de Bloqueio são utilizadas para implementar as consultas produtor-consumidor.
• As filas de bloqueio não suportam elementos nulos. Nas filas de bloqueio, se for tentado qualquer trabalho semelhante a valores nulos, o NullPointerException também será lançado.

Implementação de fila

Classes usadas na implementação de Queue

As classes utilizadas para implementar as funcionalidades da fila são fornecidas a seguir:

• ArrayDeque
• Lista vinculada
• Fila de prioridade

Interfaces usadas na implementação de Queue

As interfaces Java também são usadas na implementação da fila Java. As interfaces usadas para implementar as funcionalidades da fila são fornecidas a seguir:

• De que
• Fila de bloqueio
• Bloqueio de Deque

Métodos de classe de fila Java

Na fila Java, existem muitos métodos que são usados ​​com muita frequência. A interface Queue promove diferentes métodos como insert, delete, peek, etc. Algumas das operações da fila Java geram uma exceção, enquanto algumas dessas operações retornam um valor específico quando o programa é concluído.

Nota - No Java SE 8, não há alterações feitas na coleção de filas Java. Esses métodos definidos em são preparados posteriormente nas versões seguintes da linguagem de programação Java. Por exemplo, Java SE 9.

Diferentes métodos da fila Java são definidos abaixo:

Implementação de matriz de fila Java

A implementação da fila não é tão simples quanto a implementação da pilha.

Para implementar a fila usando Arrays, primeiro declaramos um array que contém n números de elementos.

altura de kat timpf

Em seguida, definimos as seguintes operações a serem realizadas nesta fila.

1) Enfileirar: Uma operação para inserir um elemento na fila é Enqueue (função fila Enqueue no programa). Para inserir um elemento no final, precisamos primeiro verificar se a fila está cheia. Se estiver cheio, não poderemos inserir o elemento. Se traseiro

2) Cauda: A operação para excluir um elemento da fila é Dequeue (função fila Dequeue no programa). Primeiro, verificamos se a fila está vazia. Para que a operação de desenfileiramento funcione, deve haver pelo menos um elemento na fila.

3) Frente: Este método retorna o início da fila.

4) Exibição: Este método percorre a fila e exibe os elementos da fila.

Programa de fila Java

O programa Java a seguir demonstra a implementação de Queue.

QueueArrayImplementation.java

 class Queue { private static int front, rear, capacity; private static int queue[]; Queue(int size) { front = rear = 0; capacity = size; queue = new int[capacity]; } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue[rear] = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
&apos;); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i <rear 0 4 - 1; i++) { queue[i]="queue[i" + 1]; } set queue[rear] to if (rear < capacity) decrement rear rear--; return; print queue elements static void queuedisplay() int i; (front="=" rear) system.out.printf('queue is empty
'); traverse front and for (i="front;" i rear; system.out.printf(' %d , ', queue[i]); of queuefront() system.out.printf('
front element the queue: %d', queue[front]); public class queuearrayimplementation main(string[] args) create a capacity q="new" queue(4); system.out.println('initial queue:'); q.queuedisplay(); inserting in q.queueenqueue(10); q.queueenqueue(30); q.queueenqueue(50); q.queueenqueue(70); system.out.println('queue after enqueue operation:'); q.queuefront(); insert q.queueenqueue(90); q.queuedequeue(); system.out.printf('
queue two dequeue operations:'); pre> <p> <strong>Output:</strong> </p> <pre> Initial Queue: Queue is Empty Queue after Enqueue Operation: 10 , 30 , 50 , 70 , Front Element of the queue: 10 Queue is full 10 , 30 , 50 , 70 , Queue after two dequeue operations: 50 , 70 , Front Element of the queue: 50 </pre> <h2>Java Queue Linked List Implementation</h2> <p>As we have implemented the Queue data structure using Arrays in the above program, we can also implement the Queue using Linked List.</p> <p>We will implement the same methods enqueue, dequeue, front, and display in this program. The difference is that we will be using the Linked List data structure instead of Array.</p> <p>The below program demonstrates the Linked List implementation of Queue in Java.</p> <p> <strong>QueueLLImplementation.java</strong> </p> <pre> class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front &amp; rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println(&apos;Element &apos; + data+ &apos; removed from the queue&apos;); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println(&apos;Element &apos; + data+ &apos; added to the queue&apos;); } //print front and rear of the queue public void print_frontRear() { System.out.println(&apos;Front of the queue:&apos; + front.data + &apos; Rear of the queue:&apos; + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } </pre> <p> <strong>Output:</strong> </p> <pre> Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9 </pre> <hr></rear>

Implementação de lista vinculada de fila Java

Como implementamos a estrutura de dados da Fila usando Arrays no programa acima, também podemos implementar a Fila usando a Lista Vinculada.

Implementaremos os mesmos métodos enfileirar, desenfileirar, front e exibir neste programa. A diferença é que usaremos a estrutura de dados Linked List em vez de Array.

O programa abaixo demonstra a implementação de lista vinculada de fila em Java.

QueueLLImplementation.java

travessia em ordem de árvore binária

 class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } 

Saída:

 Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9