java priority queue tutorial implementation examples
Este tutorial explica a fila de prioridade Java e conceitos relacionados, como Comparador, Fila de prioridade mínima e máxima, juntamente com sua implementação com exemplos:
A estrutura de dados da fila prioritária é uma fila especial na qual os elementos estão presentes não de acordo com a ordem FIFO, mas de acordo com os elementos naturais ou qualquer comparador personalizado usado durante a criação da fila.
=> Dê uma olhada no guia para iniciantes em Java aqui.
O que você aprenderá:
Fila prioritária em Java
Na fila prioritária, a frente da fila tem o menor número de elementos de acordo com a ordem natural e a parte traseira é apontada para o maior elemento na fila.
Um exemplo de fila de prioridade consistindo em números é mostrado abaixo.
melhor maneira de converter youtube para mp4
Portanto, quando um elemento é removido da fila de prioridade mostrada acima, então ele será o menor elemento.
Da mesma forma, para uma fila de prioridade alfabética, os valores ASCII serão considerados e os elementos da fila serão ordenados de acordo com os valores ASCII.
Listados abaixo estão algumas das principais características da PriorityQueue:
- PriorityQueue é uma fila não ligada.
- PriorityQueue não permite valores nulos.
- Para objetos não comparáveis, não podemos criar uma fila de prioridade.
- PriorityQueue herda de classes como AbstractQueue, AbstractCollection, Collection e Object.
- A cabeça ou frente da fila contém o mínimo de elementos de acordo com a ordem natural.
- A implementação da fila de prioridade não é segura para threads. Portanto, se desejarmos acesso sincronizado, devemos usar o PriorityBlockingQueue.
A classe PriorityQueue herda a Java Queue Interface e faz parte do pacote java.util.
A declaração geral da classe PriorityQueue é fornecida abaixo:
public class PriorityQueue extends AbstractQueue implements Serializable
O diagrama abaixo mostra a hierarquia de classes para a classe PriorityQueue.
Complexidade de tempo da fila de prioridade
- A complexidade de tempo da Fila de prioridade para os métodos de inserção (enfileiramento) e exclusão (desenfileiramento) é O (log (n)).
- A fila prioritária tem complexidade de tempo linear para remoção, bem como contém métodos.
- Os métodos que recuperam elementos da Fila de prioridade têm complexidade de tempo constante.
Exemplo de fila prioritária em Java
O programa a seguir demonstra um PriorityQueue simples em Java. Criamos um objeto da classe PriorityQueue, adicionamos valores a ele e, em seguida, exibimos o conteúdo da Queue usando o Iterator.
import java.util.*; class Main{ public static void main(String args[]){ PriorityQueue cities_queue=new PriorityQueue(); //initialize the PriorityQueue with values cities_queue.add('Sydney'); cities_queue.add('Venice'); cities_queue.add('New York'); cities_queue.add('California'); cities_queue.add('Melbourne'); //print the head of the PriorityQueue System.out.println('PriorityQueue Head:'+cities_queue.element()); //Define the iterator for PriorityQueue and print its elements System.out.println('
PriorityQueue contents:'); Iterator iter=cities_queue.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } } }
Resultado:
Métodos Java Priority Queue API
Construtores:
Protótipo de Construtor | Descrição | |
---|---|---|
olhadinha | E peek () | Retorna o início da fila sem excluir o elemento. |
Fila de prioridade () | Um construtor padrão que cria um objeto PriorityQueue com capacidade inicial de 1. | |
PriorityQueue (coleção c) | Cria um objeto PriorityQueue com elementos iniciais de uma determinada coleção c. | |
PriorityQueue (int initialCapacity) | Cria um objeto PriorityQueue com a ‘initialCapacity’ fornecida. Os elementos são ordenados de acordo com a ordem natural. | |
PriorityQueue (int initialCapacity, Comparator comparator) | Cria um objeto PriorityQueue com a ‘initialCapacity’ fornecida. Os elementos são ordenados de acordo com o comparador fornecido. | |
PriorityQueue (PriorityQueue c) | Cria um objeto PriorityQueue a partir de outro objeto PriorityQueue fornecido por c. | |
PriorityQueue (SortedSet c) | Cria um objeto PriorityQueue a partir de um SortedSet fornecido por c. |
Métodos
Método | Protótipo de Método | Descrição |
---|---|---|
adicionar | adição booleana (E e) | Adiciona o elemento e ao PriorityQueue. |
Claro | void clear () | Limpa o PriorityQueue excluindo todos os elementos. |
comparador | Comparatorcomparator () | Retorna um comparador customizado usado para ordenar os elementos na Fila. |
contém | boolean contém (objeto o) | Verifica se PriorityQueue contém o elemento o fornecido. Retorna verdadeiro se sim. |
iterador | Iteratoriterator () | Método para obter um iterador para o PriorityQueue fornecido. |
oferta | oferta booleana (E e) | Insira o elemento e fornecido em PriorityQueue. |
enquete | E poll () | Remove e retorna o topo da fila. Retorna nulo se a fila estiver vazia. |
retirar | boolean remove (objeto o) | Remove uma instância de um determinado elemento o se ele estiver presente na fila. |
Tamanho | tamanho interno () | Retorna o tamanho ou número de elementos neste PriorityQueue. |
toArray | Object [] toArray () | Retorna uma representação de matriz de PriorityQueue fornecido. |
toArray | T [] toArray (T [] a) | Retorna uma representação de matriz para a Fila de prioridade fornecida com o mesmo tipo de tempo de execução que a matriz especificada a. |
Implementação em Java
Vamos demonstrar os métodos acima de PriorityQueue usando um programa Java.
import java.util.*; class Main { public static void main(String args[]) { // Creating empty priority queue PriorityQueue numQueue = new PriorityQueue(); // add elements to numQueue using add() numQueue.add('Five'); numQueue.add('One'); numQueue.add('Seven'); numQueue.add('Three'); numQueue.add('Eleven'); numQueue.add('Nine'); // Print the head element using Peek () method System.out.println('Head element using peek method:' + numQueue.peek()); // Printing all elements System.out.println('
The PriorityQueue elements:'); Iterator iter1 = numQueue.iterator(); while (iter1.hasNext()) System.out.print(iter1.next() + ' '); // remove head with poll () numQueue.poll(); System.out.println('
After removing an element' + 'with poll function:'); Iterator iter2 = numQueue.iterator(); while (iter2.hasNext()) System.out.print(iter2.next() + ' '); // Remove 'Three' using remove () numQueue.remove('Three'); System.out.println('
Element 'Three' with' + ' remove function:'); Iterator iter3 = numQueue.iterator(); while (iter3.hasNext()) System.out.print(iter3.next() + ' '); // Check if an element is present in PriorityQueue using contains() boolean ret_val = numQueue.contains('Five'); System.out.println('
Priority queue contains 'Five' ' + 'or not?: ' + ret_val); // get array equivalent of PriorityQueue with toArray () Object[] numArr = numQueue.toArray(); System.out.println('
Array Contents: '); for (int i = 0; i Resultado:
objetos de negócios entrevista perguntas e respostas
Fila de prioridade em Java 8
Java 8 adiciona mais um método à classe PriorityQueue, ou seja, ‘spliterator ()’.
Os detalhes deste método são fornecidos abaixo.
Nome do método: divisor
Protótipo do método: public final Spliterator spliterator ()
Descrição do método: Este método cria um divisor sobre os elementos PriorityQueue. Este divisor é de ligação tardia e rápido contra falhas.
Comparador de fila de prioridade
Como já mencionado, os elementos PriorityQueue são ordenados naturalmente. Se quisermos mudar a ordem, devemos especificar um comparador e usá-lo durante a criação do objeto PriorityQueue. O PriorityQueue então usa esse comparador para ordenar seus elementos.
O programa Java abaixo demonstra o uso de comparador personalizado para ordenação de elementos. Neste programa, definimos um novo comparador personalizado dentro do qual substituímos o método ‘compare’. O método de comparação é usado para ordenar os elementos de PriorityQueue de acordo com o comprimento.
import java.util.*; public class Main { public static void main(String[] args) { // A custom comparator that compares two Strings by their length. Comparator customComparator = new Comparator() { @Override public int compare(String s1, String s2) { return s1.length() - s2.length(); } }; // Create a Priority Queue with a custom Comparator PriorityQueue colorsPriorityQueue = new PriorityQueue(customComparator); // Add items to a Priority Queue colorsPriorityQueue.add('Red'); colorsPriorityQueue.add('Green'); colorsPriorityQueue.add('Blue'); colorsPriorityQueue.add('Cyan'); colorsPriorityQueue.add('Magenta'); colorsPriorityQueue.add('Yellow'); // Printing all elements System.out.println('
The PriorityQueue elements with custom Comparator:'); Iterator iter1 = colorsPriorityQueue.iterator(); while (iter1.hasNext()) System.out.print(iter1.next() + ' '); } }
Resultado:
Fila de prioridade mínima em Java
A ordem natural da Fila de prioridade tem o menor ou o menor elemento no início da fila e, portanto, a ordem é crescente. Isso é chamado de “Fila de prioridade mínima” com ordem crescente de elementos.
O programa Java abaixo mostra a implementação do Min Priority Queue em Java.
import java.util.*; class Main{ public static void main(String args[]){ //declare a PriorityQueue object with default ordering PriorityQueue pq = new PriorityQueue(); //add element to the PriorityQueue pq.add(8); pq.add(6); pq.add(4); pq.add(2); pq.add(12); pq.add(10); //display the min PriorityQueue System.out.println('The min Priority Queue (natural ordering) contents:'); Integer val = null; while( (val = pq.poll()) != null) { System.out.print(val + ' '); } } }
Resultado:
Fila de prioridade máxima em Java
Enquanto a fila de prioridade mínima tem elementos em ordem crescente, a fila de prioridade máxima tem os elementos em ordem decrescente, ou seja, o chefe da fila de prioridade máxima retornará o maior elemento na fila.
assert () c ++
O programa Java abaixo demonstra o Max Priority Queue em Java.
import java.util.*; class Main{ public static void main(String args[]){ //declare a PriorityQueue object with custom comparator to generate max PQ PriorityQueue pq = new PriorityQueue(new Comparator() { public int compare(Integer lhs, Integer rhs) { if (lhs Resultado:
Conforme mostrado no programa acima, para alterar a ordem natural dos elementos na fila de prioridade, temos que definir um comparador personalizado.
perguntas frequentes
P # 1) Qual é a fila de prioridade em Java?
Responda: Uma fila especial na qual todos os elementos da fila são ordenados de acordo com a ordem natural ou usando um comparador personalizado é chamada de fila Prioritária. Não segue a ordem FIFO.
P # 2) Como você define uma fila de prioridade máxima em Java?
Responda: Podemos definir uma Fila de Prioridade Máxima em Java usando um comparador customizado para que o chefe da fila retorne o maior elemento da fila.
P # 3) A fila Priority permite duplicatas Java?
Responda: sim. A fila de prioridade permite valores duplicados.
P # 4) A fila de prioridade Java é máxima ou mínima?
Responda: Por padrão, a fila de prioridade em Java é a fila de prioridade mínima com ordenação natural. Para torná-lo máximo, temos que usar um comparador personalizado para que o chefe da fila retorne o maior elemento da fila.
P # 5) Uma fila prioritária é classificada?
Responda: Por padrão, a cabeça da fila é classificada e a fila Prioridade tem o menor elemento como cabeça. O restante dos elementos é solicitado quando necessário.
Conclusão
Isso conclui o tutorial sobre Filas prioritárias em Java. Priority Queue implementa uma interface de fila e é uma fila especial onde os elementos são ordenados de acordo com a ordem natural. Não segue a ordem FIFO. Para alterar a ordem natural da fila de prioridade, podemos usar o comparador personalizado.
As filas prioritárias são usadas principalmente para agendamento de impressora, agendamento de tarefas de CPU, etc. O heap (mínimo ou máximo) também é implementado usando Filas prioritárias.
=> Leia a série de treinamento Easy Java.
Leitura recomendada
- Estrutura de dados da fila de prioridade em C ++ com ilustração
- Fila prioritária em STL
- Java Queue - métodos de fila, implementação de fila com exemplos
- Estrutura de dados da fila circular C ++: implementação e aplicativos
- Double Ended Queue (Deque) em C ++ com exemplos
- Estrutura de dados da fila em C ++ com ilustração
- Pilhas e filas em STL
- Tutorial JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java