Ändern Sie priorityQueue in die maximale Prioritätswarteschlange

Habe ich priority-queue in Java Ganzzahlen:

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

Wenn ich rufe pq.poll() ich bekomme das minimale element.

Frage: wie ändern Sie den code, um das maximale element?

Kommentar zu dem Problem

Ich denke, Sie sollten verwenden Sie den Konstruktor, der erhält einen Komparator. Nutzung der Sammlungen.reverseOrder erhalten Sie eine umgekehrte Komparator. Kommentarautor: Edwin Dalorzo

du musst einen comparator. siehe stackoverflow.com/questions/683041/... Kommentarautor: DarthVader

InformationsquelleAutor der Frage Borut Flis | 2012-06-12

144

Wie etwa wie diese:
```
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);
}
```
Den Collections.reverseOrder() bietet eine Comparator würde Sortieren Sie die Elemente in der PriorityQueue in die entgegengesetzte Reihenfolge Ihrer natürlichen Reihenfolge, in diesem Fall.

InformationsquelleAutor der Antwort Edwin Dalorzo
33

Können Sie lambda-Ausdruck, da Java 8.

Dem folgenden code wird 10 ausgeben, die größer sind.
```
PriorityQueue<Integer> pq = new PriorityQueue<>((x, y) -> y - x);
pq.add(10);
pq.add(5);
System.out.println(pq.peek());
```
Lambda-Funktion zwei Ganzzahlen als Eingabe-Parameter, subtrahieren Sie von einander, und die arithmetische Folge. Die lambda-Funktion implementiert, die Funktionale Schnittstelle Comparator<T>. (Dies wird in Ort, als Gegensatz zu einer anonymen Klasse oder eine diskrete Umsetzung.)

InformationsquelleAutor der Antwort Guangtong Shen

Können Sie eine benutzerdefinierte Comparator Objekt-Reihen in umgekehrter Reihenfolge:

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

Nun, die Priorität umkehren wird, alle seine Vergleiche, so erhalten Sie die maximale element und nicht als das minimale element.

Hoffe, das hilft!

InformationsquelleAutor der Antwort templatetypedef

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

InformationsquelleAutor der Antwort Varun Juneja

Die Elemente der priority-queue sind, geordnet nach Ihrer natürlichen Reihenfolge oder mit einem Komparator bereitgestellt, an der Warteschlange der Bauzeit.

Den Komparator sollte das überschreiben der Methode vergleichen.

int compare(T o1, T o2)

Standard-compare-Methode gibt eine negative ganze Zahl, null oder eine positive ganze Zahl als das erste argument kleiner, gleich oder größer als das zweite.

Den Standard-PriorityQueue zur Verfügung gestellt von Java ist die Min-Heap, Wenn Sie möchten, dass ein max-heap folgenden ist der code

public class Sample {
    public static void main(String[] args) {
        PriorityQueue<Integer> q = new PriorityQueue<Integer>(new Comparator<Integer>() {

            public int compare(Integer lhs, Integer rhs) {
                if(lhs<rhs) return +1;
                if(lhs>rhs) return -1;
                return 0;
            }
        });
        q.add(13);
        q.add(4);q.add(14);q.add(-4);q.add(1);
        while (!q.isEmpty()) {
            System.out.println(q.poll());
        }
    }

}

Referenz :https://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html#comparator()

InformationsquelleAutor der Antwort rohan

Hier ist eine Beispiel-Max-Heap in Java :

PriorityQueue<Integer> pq1= new PriorityQueue<Integer>(10, new Comparator<Integer>() {
public int compare(Integer x, Integer y) {
if (x < y) return 1;
if (x > y) return -1;
return 0;
}
});
pq1.add(5);
pq1.add(10);
pq1.add(-1);
System.out.println("Peek: "+pq1.peek());

Ist die Ausgabe 10

InformationsquelleAutor der Antwort Nobal

2

Können Sie MinMaxPriorityQueue (es ist ein Teil der Guava-Bibliothek):
hier ist die Dokumentation. Statt poll(), müssen Sie rufen Sie die pollLast() Methode.

InformationsquelleAutor der Antwort Chthonic Project

Ich lief ein Monte-Carlo-simulation auf beide Komparatoren auf Doppel-heap-sort, min, max, und Sie beide kamen zu dem gleichen Ergebnis:

Diese sind das max Komparatoren, die ich verwendet habe:

(A) Sammlungen eingebauten Komparator

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

(B) Benutzerdefinierte Komparator -

PriorityQueue<Integer> heapLow = new PriorityQueue<Integer>(new Comparator<Integer>() {
    int compare(Integer lhs, Integer rhs) {
        if (rhs > lhs) return +1;
        if (rhs < lhs) return -1;
        return 0;
    }
});

InformationsquelleAutor der Antwort sivi

0

Können Sie versuchen, schieben Elemente mit umgekehrtem Vorzeichen. Eg: hinzufügen a=2 & b=5 und dann poll b=5.
```
PriorityQueue<Integer>  pq = new PriorityQueue<>();
pq.add(-a);
pq.add(-b);
System.out.print(-pq.poll());
```
Sobald Sie Umfrage der Kopf der Schlange, in umgekehrter Zeichen für Ihre Nutzung.
Dies wird print 5 (größere element). Kann verwendet werden in naiven Implementierungen. Definitiv nicht zuverlässig beheben. Ich empfehle es nicht.

InformationsquelleAutor der Antwort striker28
0

Können Sie versuchen so etwas wie:
```
PriorityQueue<Integer> pq = new PriorityQueue<>((x, y) -> -1 * Integer.compare(x, y));
```
Die funktioniert auch für jede andere Basis Vergleich-Funktion, die Sie haben könnten.

InformationsquelleAutor der Antwort Horia Coman

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.