我在整数Java中有优先级队列：
PriorityQueue<Integer> pq= new PriorityQueue<Integer>();
当我致电pq.poll()时，我得到了最小元素。
问题：如何更改代码以获取最大元素？
答案 0 :(得分：171)
这样怎么样：
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);
}
Collections.reverseOrder()提供了Comparator，在这种情况下，PriorityQueue会按照对位顺序将{{1}}中的元素排序为自然顺序。
答案 1 :(得分：46)
您可以使用自Java 8以来的lambda表达式。
以下代码将打印10，更大。
PriorityQueue<Integer> pq = new PriorityQueue<>((x, y) -> y - x);
pq.add(10);
pq.add(5);
System.out.println(pq.peek());
lambda函数将两个Integers作为输入参数，相互减去它们，并返回算术结果。 lambda函数实现了功能接口Comparator<T>。 （这是使用的，而不是匿名类或离散实现。）
答案 2 :(得分：21)
您可以提供自定义Comparator对象，以相反的顺序对元素进行排名：
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;
}
});
现在，优先级队列将反转所有比较，因此您将获得最大元素而不是最小元素。
希望这有帮助！
答案 3 :(得分：13)
在Java 8+中，您可以通过以下方法之一创建最大优先级队列：
方法1：
PriorityQueue<Integer> maxPQ = new PriorityQueue<>(Collections.reverseOrder());
方法2：
PriorityQueue<Integer> maxPQ = new PriorityQueue<>((a,b) -> b - a);
方法3：
PriorityQueue<Integer> maxPQ = new PriorityQueue<>((a,b) -> b.compareTo(a));
答案 4 :(得分：12)
PriorityQueue<Integer> pq = new PriorityQueue<Integer> (
new Comparator<Integer> () {
public int compare(Integer a, Integer b) {
return b - a;
}
}
);
答案 5 :(得分：8)
优先级队列的元素按照其自然顺序排序，或者由队列构建时提供的比较器排序。
比较器应该覆盖比较方法。
int compare(T o1, T o2)
默认比较方法返回负整数，零或正整数，因为第一个参数小于，等于或大于第二个参数。
Java提供的Default PriorityQueue是Min-Heap，如果你想要跟随最大堆是代码
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());
}
}
}
答案 6 :(得分：4)
以下是Java中的Max-Heap示例：
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());
输出为10
答案 7 :(得分：3)
您可以使用MinMaxPriorityQueue（它是Guava库的一部分）：
here's the documentation。您需要调用poll()方法而不是pollLast()。
答案 8 :(得分：2)
我们可以通过创建实现Comparator接口的 CustomComparator 类并覆盖其compare方法来做到这一点。下面是相同的代码：
import java.util.PriorityQueue;
import java.util.Comparator;
public class Main
{
public static void main(String[] args) {
PriorityQueue<Integer> nums = new PriorityQueue<>(new CustomComparator());
nums.offer(21);
nums.offer(1);
nums.offer(8);
nums.offer(2);
nums.offer(-4);
System.out.println(nums.peek());
}
}
class CustomComparator implements Comparator<Integer>{
@Override
public int compare(Integer n1, Integer n2){
int val = n1.compareTo(n2);
if(val > 0)
return -1;
else if(val < 0)
return 1;
else
return 0;
}
}
答案 9 :(得分：1)
我刚刚在双堆排序最小值上对两个比较器进行了蒙特卡罗模拟，它们都得出了相同的结果：
这些是我使用的最大比较器：
（A）集合内置比较器
PriorityQueue<Integer> heapLow = new PriorityQueue<Integer>(Collections.reverseOrder());
（B）自定义比较器
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;
}
});
答案 10 :(得分：1)
您可以尝试以下内容：
PriorityQueue<Integer> pq = new PriorityQueue<>((x, y) -> -1 * Integer.compare(x, y));
适用于您可能拥有的任何其他基本比较功能。
答案 11 :(得分：1)
将PriorityQueue更改为MAX PriorityQueue 方法1：队列pq = new PriorityQueue <>（Collections.reverseOrder（））; 方法2：队列pq1 = new PriorityQueue <>（（（a，b）-> b-a）; 让我们看几个例子：
public class Example1 {
public static void main(String[] args) {
List<Integer> ints = Arrays.asList(222, 555, 666, 333, 111, 888, 777, 444);
Queue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
pq.addAll(ints);
System.out.println("Priority Queue => " + pq);
System.out.println("Max element in the list => " + pq.peek());
System.out.println("......................");
// another way
Queue<Integer> pq1 = new PriorityQueue<>((a, b) -> b - a);
pq1.addAll(ints);
System.out.println("Priority Queue => " + pq1);
System.out.println("Max element in the list => " + pq1.peek());
/* OUTPUT
Priority Queue => [888, 444, 777, 333, 111, 555, 666, 222]
Max element in the list => 888
......................
Priority Queue => [888, 444, 777, 333, 111, 555, 666, 222]
Max element in the list => 888
*/
}
}
让我们接受著名的采访 问题：使用PriorityQueue数组中第K个最大元素
public class KthLargestElement_1{
public static void main(String[] args) {
List<Integer> ints = Arrays.asList(222, 555, 666, 333, 111, 888, 777, 444);
int k = 3;
Queue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
pq.addAll(ints);
System.out.println("Priority Queue => " + pq);
System.out.println("Max element in the list => " + pq.peek());
while (--k > 0) {
pq.poll();
} // while
System.out.println("Third largest => " + pq.peek());
/*
Priority Queue => [888, 444, 777, 333, 111, 555, 666, 222]
Max element in the list => 888
Third largest => 666
*/
}
}
另一种方式：
public class KthLargestElement_2 {
public static void main(String[] args) {
List<Integer> ints = Arrays.asList(222, 555, 666, 333, 111, 888, 777, 444);
int k = 3;
Queue<Integer> pq1 = new PriorityQueue<>((a, b) -> b - a);
pq1.addAll(ints);
System.out.println("Priority Queue => " + pq1);
System.out.println("Max element in the list => " + pq1.peek());
while (--k > 0) {
pq1.poll();
} // while
System.out.println("Third largest => " + pq1.peek());
/*
Priority Queue => [888, 444, 777, 333, 111, 555, 666, 222]
Max element in the list => 888
Third largest => 666
*/
}
}
我们看到，两者给出的结果相同。
答案 12 :(得分：0)
这可以通过Java 8中的以下代码来实现，该代码引入了仅使用比较器的构造函数。
PriorityQueue<Integer> maxPriorityQ = new PriorityQueue<Integer>(Collections.reverseOrder());
答案 13 :(得分：0)
PriorityQueue<Integer> lowers = new PriorityQueue<>((o1, o2) -> -1 * o1.compareTo(o2));
答案 14 :(得分：0)
这可以通过使用
来实现PriorityQueue<Integer> pq = new PriorityQueue<Integer>(Collections.reverseOrder());
答案 15 :(得分：0)
使用lamda，将结果乘以-1即可获得最大优先级队列。
PriorityQueue<> q = new PriorityQueue<Integer>(
(a,b) -> -1 * Integer.compare(a, b)
);
答案 16 :(得分：-1)
您可以尝试使用反向符号推送元素。例如：添加= 2＆amp; b = 5，然后轮询b = 5.
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(-a);
pq.add(-b);
System.out.print(-pq.poll());
一旦您轮询队列的头部，请反转您使用的标志。 这将打印5（更大的元素）。可以在天真的实现中使用。绝对不是一个可靠的解决方案。我不推荐它。