Changez priorityQueueue en priorityqueue max

Question

J'ai une file d'attente prioritaire d'entiers en Java :

 PriorityQueue<Integer> pq= new PriorityQueue<Integer>();

Quand j'appelle pq.poll() J'obtiens l'élément minimum.

Question : comment modifier le code pour obtenir l'élément maximum ?

Answer 1

Et comme ça :

PriorityQueue<Integer> queue = new PriorityQueue<>(10, Collections.reverseOrder());
queue.offer(1);
queue.offer(2);
queue.offer(3);
//...

Integer val = null;
while( (val = queue.poll()) != null) {
    System.out.println(val);
}

El Collections.reverseOrder() fournit un Comparator qui trierait les éléments dans le PriorityQueue dans un ordre opposé à leur ordre naturel dans ce cas.

Answer 2

Vous pouvez utiliser l'expression lambda depuis Java 8.

Le code suivant imprimera 10, le plus grand.

// There is overflow problem when using simple lambda as comparator, as pointed out by Фима Гирин.
// PriorityQueue<Integer> pq = new PriorityQueue<>((x, y) -> y - x);

PriorityQueue<Integer> pq =new PriorityQueue<>((x, y) -> Integer.compare(y, x));

pq.add(10);
pq.add(5);
System.out.println(pq.peek());

La fonction lambda prend deux entiers comme paramètres d'entrée, les soustrait l'un de l'autre et renvoie le résultat arithmétique. La fonction lambda implémente l'interface fonctionnelle, Comparator<T> . (Ceci est utilisé à la place, par opposition à une classe anonyme ou une implémentation discrète).

Answer 3

En Java 8+, vous pouvez créer une file d'attente à priorité maximale via l'une de ces méthodes :

Méthode 1 :

PriorityQueue<Integer> maxPQ = new PriorityQueue<>(Collections.reverseOrder()); 

Méthode 2 :

PriorityQueue<Integer> maxPQ = new PriorityQueue<>((a,b) -> b - a); 

Méthode 3 :

PriorityQueue<Integer> maxPQ = new PriorityQueue<>((a,b) -> b.compareTo(a));

Answer 4

Vous pouvez fournir un Comparator qui classe les éléments dans l'ordre inverse :

PriorityQueue<Integer> pq = new PriorityQueue<Integer>(defaultSize, new Comparator<Integer>() {
    public int compare(Integer lhs, Integer rhs) {
        if (lhs < rhs) return +1;
        if (lhs.equals(rhs)) return 0;
        return -1;
    }
});

Maintenant, la file d'attente prioritaire va inverser toutes ses comparaisons, de sorte que vous obtiendrez l'élément maximal plutôt que l'élément minimal.

J'espère que cela vous aidera !

Answer 5

PriorityQueue<Integer> pq = new PriorityQueue<Integer> (
  new Comparator<Integer> () {
    public int compare(Integer a, Integer b) {
       return b - a;
    }
  }
);