blocks|key|330275|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|330276|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);
}|code-block|syntax|javascript|330277|Collections.reverseOrder()提供了一个Comparator，它将PriorityQueue中的元素按相反的顺序排序，在本例中为它们的自然顺序。|offset|length|style|CODE|330278|entityMap^0|0|0|0|Q|V|A|18|D|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

How about like this:

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

Integer val = null;
while( (val = queue.poll()) != null) {
 System.out.println(val);
}
</code></pre>

The <code>Collections.reverseOrder()</code> provides a <code>Comparator</code> that would sort the elements in the <code>PriorityQueue</code> in a the oposite order to their natural order in this case.

blocks|key|547276|text|从Java+8开始就可以使用lambda表达式了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547277|下面的代码将打印较大的10。|547278|//+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());|code-block|syntax|javascript|547279|lambda函数将接受两个整数作为输入参数，将它们相减，然后返回算术结果。lambda函数实现了函数接口Comparator<T>。(这是就地使用的，而不是匿名类或离散实现。)|offset|length|style|CODE|547280|entityMap^0|0|0|0|1G|D|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You can use lambda expression since Java 8.

The following code will print 10, the larger.

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

PriorityQueue&lt;Integer&gt; pq =new PriorityQueue&lt;&gt;((x, y) -&gt; Integer.compare(y, x));

pq.add(10);
pq.add(5);
System.out.println(pq.peek());
</code></pre>

The lambda function will take two Integers as input parameters, subtract them from each other, and return the arithmetic result. The lambda function implements the Functional Interface, <code>Comparator&lt;T&gt;</code>. (This is used in place, as opposed to an anonymous class or a discrete implementation.)

blocks|key|547600|text|在Java+8%2B中，您可以通过以下方法之一创建最大优先级队列：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547601|方法1：|547602|PriorityQueue<Integer>+maxPQ+=+new+PriorityQueue<>(Collections.reverseOrder());+|code-block|syntax|javascript|547603|方法二：|547604|PriorityQueue<Integer>+maxPQ+=+new+PriorityQueue<>((a,b)+->+b+-+a);+|547605|方法3：|547606|PriorityQueue<Integer>+maxPQ+=+new+PriorityQueue<>((a,b)+->+b.compareTo(a));+|547607|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

In Java 8+ you can create a max priority queue via one of these methods: 

Method 1: 

<pre><code>PriorityQueue&lt;Integer&gt; maxPQ = new PriorityQueue&lt;&gt;(Collections.reverseOrder()); 
</code></pre>

Method 2: 

<pre><code>PriorityQueue&lt;Integer&gt; maxPQ = new PriorityQueue&lt;&gt;((a,b) -&gt; b - a); 
</code></pre>

Method 3: 

<pre><code>PriorityQueue&lt;Integer&gt; maxPQ = new PriorityQueue&lt;&gt;((a,b) -&gt; b.compareTo(a)); 
</code></pre>

blocks|key|330218|text|您可以提供一个按相反顺序排列元素的自定义Comparator对象：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|330219|PriorityQueue<Integer>+pq+=+new+PriorityQueue<Integer>(defaultSize,+new+Comparator<Integer>()+{
++++public+int+compare(Integer+lhs,+Integer+rhs)+{
++++++++if+(lhs+<+rhs)+return+%2B1;
++++++++if+(lhs.equals(rhs))+return+0;
++++++++return+-1;
++++}
});|code-block|syntax|javascript|330220|现在，优先级队列将反转所有比较，因此您将获得最大元素，而不是最小元素。|330221|希望这能有所帮助！|330222|entityMap^0|K|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|V|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You can provide a custom <code>Comparator</code> object that ranks elements in the reverse order:

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

Now, the priority queue will reverse all its comparisons, so you will get the maximum element rather than the minimum element.

Hope this helps!

blocks|key|330394|text|PriorityQueue<Integer>+pq+=+new+PriorityQueue<Integer>+(
++new+Comparator<Integer>+()+{
++++public+int+compare(Integer+a,+Integer+b)+{
+++++++return+b+-+a;
++++}
++}
);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|330395|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>PriorityQueue&lt;Integer&gt; pq = new PriorityQueue&lt;Integer&gt; (
 new Comparator&lt;Integer&gt; () {
 public int compare(Integer a, Integer b) {
 return b - a;
 }
 }
);
</code></pre>

blocks|key|330546|text|优先级队列的元素根据它们的自然排序来排序，或者由在队列构造时提供的比较器排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|330547|比较器应该重写compare方法。|330548|int+compare(T+o1,+T+o2)|code-block|syntax|javascript|330549|默认的compare方法返回负整数、零或正整数，因为第一个参数小于、等于或大于第二个参数。|330550|Java提供的默认PriorityQueue是最小堆，如果您想要最大堆，下面是代码|330551|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+%2B1;
++++++++++++++++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());
++++++++}
++++}

}|330552|参考:https://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html#comparator()|offset|length|330553|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html#comparator()^0|0|0|0|0|0|0|3|2B|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|16|8|@]|9|@$Q|17|R|18|1|19]]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

The elements of the priority queue are ordered according to their natural ordering, or by a Comparator provided at queue construction time.

The Comparator should override the compare method.

<pre><code>int compare(T o1, T o2)
</code></pre>

Default compare method returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

The Default PriorityQueue provided by Java is Min-Heap, If you want a max heap following is the code

<pre><code>public class Sample {
 public static void main(String[] args) {
 PriorityQueue&lt;Integer&gt; q = new PriorityQueue&lt;Integer&gt;(new Comparator&lt;Integer&gt;() {

 public int compare(Integer lhs, Integer rhs) {
 if(lhs&lt;rhs) return +1;
 if(lhs&gt;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());
 }
 }

}
</code></pre>

Reference :<a href="https://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html#comparator()" rel="noreferrer">https://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html#comparator()</a>

blocks|key|547571|text|这可以通过使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547572|PriorityQueue<Integer>+pq+=+new+PriorityQueue<Integer>(Collections.reverseOrder());|code-block|syntax|javascript|547573|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This can be achieved by using 

<pre><code>PriorityQueue&lt;Integer&gt; pq = new PriorityQueue&lt;Integer&gt;(Collections.reverseOrder());
</code></pre>

blocks|key|330352|text|下面是一个用Java编写的示例Max-Heap：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|330353|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:+"%2Bpq1.peek());|code-block|syntax|javascript|330354|输出将为10|330355|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is a sample Max-Heap in Java : 

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

The output will be 10

blocks|key|547439|text|这可以通过Java+8中的以下代码来实现，它引入了一个构造函数，它只接受一个比较器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547440|PriorityQueue<Integer>+maxPriorityQ+=+new+PriorityQueue<Integer>(Collections.reverseOrder());|code-block|syntax|javascript|547441|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This can be achieved by the below code in Java 8 which has introduced a constructor which only takes a comparator.

<pre><code>PriorityQueue&lt;Integer&gt; maxPriorityQ = new PriorityQueue&lt;Integer&gt;(Collections.reverseOrder());
</code></pre>

blocks|key|330318|text|您可以使用MinMaxPriorityQueue+(它是Guava库的一部分)：here's+the+documentation。您需要调用pollLast()方法，而不是poll()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|330319|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/MinMaxPriorityQueue.html^0|5|J|1Y|A|2E|6|14|O|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

You can use <code>MinMaxPriorityQueue</code> (it's a part of the Guava library):
<a href="http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/MinMaxPriorityQueue.html" rel="nofollow">here's the documentation</a>. Instead of <code>poll()</code>, you need to call the <code>pollLast()</code> method.

blocks|key|547526|text|方法1:队列pq+=+PriorityQueue+PriorityQueue<>(Collections.reverseOrder())；方法2:队列pq1+=新PriorityQueue<>((a，b)+->+b-+a)；让我们看几个例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547527|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+=>+"+%2B+pq);
++++++++System.out.println("Max+element+in+the+list+=>+"+%2B+pq.peek());
++++++++System.out.println("......................");
++++++++//+another+way
++++++++Queue<Integer>+pq1+=+new+PriorityQueue<>((a,+b)+->+b+-+a);
++++++++pq1.addAll(ints);
++++++++System.out.println("Priority+Queue+=>+"+%2B+pq1);
++++++++System.out.println("Max+element+in+the+list+=>+"+%2B+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

+++++++++*/


++++}
}|code-block|syntax|javascript|547528|让我们来看一个著名的面试问题:使用PriorityQueue的数组中的第k个最大元素|547529|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+=>+"+%2B+pq);
++++++++System.out.println("Max+element+in+the+list+=>+"+%2B+pq.peek());
++++++++while+(--k+>+0)+{
++++++++++++pq.poll();
++++++++}+//+while
++++++++System.out.println("Third+largest+=>+"+%2B+pq.peek());
/*
+Priority+Queue+=>+[888,+444,+777,+333,+111,+555,+666,+222]
Max+element+in+the+list+=>+888
Third+largest+=>+666

+*/
++++}
}|547530|另一种方式：|547531|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+=>+"+%2B+pq1);
++++++++System.out.println("Max+element+in+the+list+=>+"+%2B+pq1.peek());
++++++++while+(--k+>+0)+{
++++++++++++pq1.poll();
++++++++}+//+while
++++++++System.out.println("Third+largest+=>+"+%2B+pq1.peek());
++++++++/*
++++++++++Priority+Queue+=>+[888,+444,+777,+333,+111,+555,+666,+222]+
++++++++++Max+element+in+the+list+=>+888+
++++++++++Third+largest+=>+666

+++++++++*/
++++}
}|547532|正如我们所看到的，两者都给出了相同的结果。|547533|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Change PriorityQueue to MAX PriorityQueue
Method 1 : Queue pq = new PriorityQueue&lt;>(Collections.reverseOrder());
Method 2 : Queue pq1 = new PriorityQueue&lt;>((a, b) -> b - a);
Let's look at few Examples:

<pre><code>public class Example1 {
 public static void main(String[] args) {

 List&lt;Integer&gt; ints = Arrays.asList(222, 555, 666, 333, 111, 888, 777, 444);
 Queue&lt;Integer&gt; pq = new PriorityQueue&lt;&gt;(Collections.reverseOrder());
 pq.addAll(ints);
 System.out.println("Priority Queue =&gt; " + pq);
 System.out.println("Max element in the list =&gt; " + pq.peek());
 System.out.println("......................");
 // another way
 Queue&lt;Integer&gt; pq1 = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);
 pq1.addAll(ints);
 System.out.println("Priority Queue =&gt; " + pq1);
 System.out.println("Max element in the list =&gt; " + pq1.peek());
 /* OUTPUT
 Priority Queue =&gt; [888, 444, 777, 333, 111, 555, 666, 222]
 Max element in the list =&gt; 888
 ......................
 Priority Queue =&gt; [888, 444, 777, 333, 111, 555, 666, 222]
 Max element in the list =&gt; 888

 */


 }
}
</code></pre>

Let's take a famous interview 
Problem : Kth Largest Element in an Array using PriorityQueue

<pre><code>public class KthLargestElement_1{
 public static void main(String[] args) {

 List&lt;Integer&gt; ints = Arrays.asList(222, 555, 666, 333, 111, 888, 777, 444);
 int k = 3;
 Queue&lt;Integer&gt; pq = new PriorityQueue&lt;&gt;(Collections.reverseOrder());
 pq.addAll(ints);
 System.out.println("Priority Queue =&gt; " + pq);
 System.out.println("Max element in the list =&gt; " + pq.peek());
 while (--k &gt; 0) {
 pq.poll();
 } // while
 System.out.println("Third largest =&gt; " + pq.peek());
/*
 Priority Queue =&gt; [888, 444, 777, 333, 111, 555, 666, 222]
Max element in the list =&gt; 888
Third largest =&gt; 666

 */
 }
}
</code></pre>

Another way : 

<pre><code>public class KthLargestElement_2 {
 public static void main(String[] args) {
 List&lt;Integer&gt; ints = Arrays.asList(222, 555, 666, 333, 111, 888, 777, 444);
 int k = 3;

 Queue&lt;Integer&gt; pq1 = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);
 pq1.addAll(ints);
 System.out.println("Priority Queue =&gt; " + pq1);
 System.out.println("Max element in the list =&gt; " + pq1.peek());
 while (--k &gt; 0) {
 pq1.poll();
 } // while
 System.out.println("Third largest =&gt; " + pq1.peek());
 /*
 Priority Queue =&gt; [888, 444, 777, 333, 111, 555, 666, 222] 
 Max element in the list =&gt; 888 
 Third largest =&gt; 666

 */
 }
}
</code></pre>

As we can see, both are giving the same result.

blocks|key|547169|text|我刚刚在两个比较器上对双堆排序min+max运行了蒙特卡洛模拟，它们都得到了相同的结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547170|下面是我用过的最大比较器：|547171|(A)集合内置比较器|547172|+PriorityQueue<Integer>+heapLow+=+new+PriorityQueue<Integer>(Collections.reverseOrder());|code-block|syntax|javascript|547173|(B)自定义比较器|547174|PriorityQueue<Integer>+heapLow+=+new+PriorityQueue<Integer>(new+Comparator<Integer>()+{
++++int+compare(Integer+lhs,+Integer+rhs)+{
++++++++if+(rhs+>+lhs)+return+%2B1;
++++++++if+(rhs+<+lhs)+return+-1;
++++++++return+0;
++++}
});|547175|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I just ran a Monte-Carlo simulation on both comparators on double heap sort min max and they both came to the same result: 

These are the max comparators I have used:

(A) Collections built-in comparator

<pre><code> PriorityQueue&lt;Integer&gt; heapLow = new PriorityQueue&lt;Integer&gt;(Collections.reverseOrder());
</code></pre>

(B) Custom comparator 

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

blocks|key|547397|text|您可以尝试执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547398|PriorityQueue<Integer>+pq+=+new+PriorityQueue<>((x,+y)+->+-1+*+Integer.compare(x,+y));|code-block|syntax|javascript|547399|它适用于您可能拥有的任何其他基本比较函数。|547400|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can try something like:

<pre><code>PriorityQueue&lt;Integer&gt; pq = new PriorityQueue&lt;&gt;((x, y) -&gt; -1 * Integer.compare(x, y));
</code></pre>

Which works for any other base comparison function you might have.

blocks|key|547451|text|PriorityQueue<Integer>+lowers+=+new+PriorityQueue<>((o1,+o2)+->+-1+*+o1.compareTo(o2));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|547452|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>PriorityQueue&lt;Integer&gt; lowers = new PriorityQueue&lt;&gt;((o1, o2) -&gt; -1 * o1.compareTo(o2));
</code></pre>

blocks|key|330427|text|您可以尝试使用反向符号推送元素。例如:添加a=2+&+b=5，然后轮询b=5。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|330428|PriorityQueue<Integer>++pq+=+new+PriorityQueue<>();
pq.add(-a);
pq.add(-b);
System.out.print(-pq.poll());|code-block|syntax|javascript|330429|一旦您轮询队列的头部，反转符号以供您使用。这将打印5(较大的元素)。可以在简单的实现中使用。绝对不是一个可靠的修复方法。我不推荐这样做。|330430|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can try pushing elements with reverse sign. Eg: To add a=2 &amp; b=5 and then poll b=5.

<pre><code>PriorityQueue&lt;Integer&gt; pq = new PriorityQueue&lt;&gt;();
pq.add(-a);
pq.add(-b);
System.out.print(-pq.poll());
</code></pre>

Once you poll the head of the queue, reverse the sign for your usage.
This will print 5 (larger element). Can be used in naive implementations. Definitely not a reliable fix. I don't recommend it.

blocks|key|330834|text|使用lamda，只需将结果与-1相乘，即可获得最大优先级队列。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|330835|PriorityQueue<>+q+=+new+PriorityQueue<Integer>(
+++++++++++++++++++++++(a,b)+->++-1+*+Integer.compare(a,+b)
++++++++++++++++++++);|code-block|syntax|javascript|330836|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Using lamda, just multiple the result with -1 to get max priority queue.
<pre><code>PriorityQueue&lt;&gt; q = new PriorityQueue&lt;Integer&gt;(
 (a,b) -&gt; -1 * Integer.compare(a, b)
 );
</code></pre>

I have priority queue in Java of Integers:

<pre><code> PriorityQueue&lt;Integer&gt; pq= new PriorityQueue&lt;Integer&gt;();
</code></pre>

When I call <code>pq.poll()</code> I get the minimum element.

Question: how to change the code to get the maximum element?

Change priorityQueue to max priorityqueue

Java

我有整数的Java优先级队列： PriorityQueue<Integer> pq= new PriorityQueue<Integer>();当我调用pq.poll()时，我得到了最小元素。问:如何更改代码以获得最大元素？

问将priorityQueue更改为最大优先级队列
EN

回答 16

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将priorityQueue更改为最大优先级队列EN

回答 16

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将priorityQueue更改为最大优先级队列
EN