Java 如何在O（1）空间中打印优先级队列的降序

我正在解决堆上的问题，我希望使用PriorityQueue按降序输出问题。
输入：
一,
5.2
125787123
输出：
23787
想要的输出：
787 23

class GFG {

public static void main(String args[])throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(br.readLine());
    while(t-->0) {
        // take array and kth element iput
        String n_k[] = br.readLine().split(" ");
        // store array size in n && kth element to find in k
        int n = Integer.parseInt(n_k[0]);
        int k = Integer.parseInt(n_k[1]);
        // Array String input
        String s[] = br.readLine().split(" ");
        int d[] = new int[n];
        for(int i = 0 ; i < n ; i++) {
            d[i] = Integer.parseInt(s[i]);
        }
        
        PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();
        // delete the minimum element in the element and just keep 
        // k greater element in the minHeap
        for(int i = 0 ; i < n; i++) {
            minHeap.add(d[i]);
            // if size of heap increases pop tht last element 
            if(minHeap.size()>k) {
                minHeap.poll();
            }
        }
        // print remaining element
        //HERE IS THE PROBLEM I WANT IT IN " DECREASING ORDER "
        // it gives me Increasing order
        while(minHeap.size() > 0) {
            System.out.print(minHeap.peek()+" ");
            minHeap.poll();
        }
        System.out.println();
    }// end of while
    
    }// end of main
 }// end of class

GFG类{
公共静态void main（字符串args[]）引发IOException{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
int t=Integer.parseInt（br.readLine（））；
而（t-->0）{
//取数组和第k个元素iput
字符串n_k[]=br.readLine（）.split（“”）；
//将数组大小存储在k中要查找的n&&k个元素中
int n=Integer.parseInt（n_k[0]）；
int k=Integer.parseInt（n_k[1]）；
//数组字符串输入
字符串s[]=br.readLine（）.split（“”）；
int d[]=新的int[n]；
对于（int i=0；ik）{
minHeap.poll（）；
}
}
//打印剩余元素
//这就是问题所在，我希望它按“降序”排列
//它给了我越来越多的订单
while（minHeap.size（）>0）{
System.out.print（minHeap.peek（）+）；
minHeap.poll（）；
}
System.out.println（）；
}//结束
}//干管末端
}//下课

输入：
一,
5.2
125787123
输出：

---

23787

只需将代码替换为以下内容即可

在声明优先级队列时，您可以按相反顺序提供比较器

PriorityQueue newHeap=newpriorityqueue（minHeap.size（），Comparator.reverseOrder（））

在这里，我创建了一个新堆，它将以reverseOrder存储所有现有元素，然后按原样执行所有现有操作

它给出了预期的答案

1
5 2
12 5 787 1 23

O/P
787 23 

这对你有帮助

  class GFG {

    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-- > 0) {
            String n_k[] = br.readLine().split(" ");
            int n = Integer.parseInt(n_k[0]);
            int k = Integer.parseInt(n_k[1]);
            String s[] = br.readLine().split(" ");
            int d[] = new int[n];
            for (int i = 0; i < n; i++) {
                d[i] = Integer.parseInt(s[i]);
            }

            PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();
            for (int i = 0; i < n; i++) {
                minHeap.add(d[i]);
                // if size of heap increases pop tht last element
                if (minHeap.size() > k) {
                    minHeap.poll();
                }
            }
            PriorityQueue<Integer> newHeap = new PriorityQueue(minHeap.size(), Comparator.reverseOrder());
            newHeap.addAll(minHeap);
            while (newHeap.size() > 0) {
                System.out.print(newHeap.peek() + " ");
                newHeap.poll();
            }
            System.out.println();
        }

    }
}

GFG类{
公共静态void main（字符串args[]）引发IOException{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
int t=Integer.parseInt（br.readLine（））；
而（t-->0）{
字符串n_k[]=br.readLine（）.split（“”）；
int n=Integer.parseInt（n_k[0]）；
int k=Integer.parseInt（n_k[1]）；
字符串s[]=br.readLine（）.split（“”）；
int d[]=新的int[n]；
对于（int i=0；ik）{
minHeap.poll（）；
}
}
PriorityQueue newHeap=newpriorityqueue（minHeap.size（），Comparator.reverseOrder（））；
addAll（minHeap）；
while（newHeap.size（）>0）{
System.out.print（newHeap.peek（）+）；
newHeap.poll（）；
}
System.out.println（）；
}
}
}

您可以使用

流

打印结果：

try (Scanner scan = new Scanner(System.in)) {
    int totalCases = scan.nextInt();

    while (totalCases-- > 0) {
        int n = scan.nextInt();
        int k = scan.nextInt();

        Queue<Integer> minHeap = new PriorityQueue<>(k);

        for (int i = 0; i < n; i++) {
            if (minHeap.size() == k)
                minHeap.remove();

            minHeap.add(scan.nextInt());
        }

        System.out.println(minHeap.stream()
                                  .sorted(Comparator.reverseOrder())
                                  .map(String::valueOf)
                                  .collect(Collectors.joining(" ")));
    }
}

try（扫描器扫描=新扫描器（System.in））{
int totalCases=scan.nextInt（）；
而（总案例-->0）{
int n=scan.nextInt（）；
int k=scan.nextInt（）；
Queue minHeap=new PriorityQueue（k）；
对于（int i=0；i

添加

PriorityQueue

不会使空间复杂度达到O（n），如果我错了，请纠正我。谢谢。是的，使用流解决了我在O（1）空间中的问题！非常感谢。