如何使用 O(logN) 对具有 n 个元素的优先级队列进行排序？

Question

我有一个整数流，以及一个由用户给出的 int k。在程序结束时，我必须打印 k 个最高的数字。我只能使用容量为 k 的优先级队列。

我的问题是当队列达到满容量时，下一个整数读取必须替换队列中的最低值。

如何在插入后保持队列排序，以便知道在下一次迭代中替换哪个 int，复杂度为 O(logn)？我使用了一种游泳方法（如下所示），但是，虽然它会将新的 int 放置在正确的级别，但它不会使队列完全排序。

游泳方法如下：

private void swim(int i){
    while (i > 1) {  //if i root (i==1) return
        int p = i/2;  //find parent
        int result = cmp.compare(heap[i], heap[p]);  //compare parent with child
        if (result == 1) return;    //if child <= parent return
        swap(i, p);                 //else swap and i=p
        i = p;
    }
} 

为了让自己更清楚，这里有一个 k = 3 的例子。

1: A = 42 / B = null / C = null

 2: A = 69 / B= 42 / C = null (69 swims upwards)

3: A = 69 / B= 42 / C = 32

 4: A = 69 / B= 42 / C = 32 (no change)

 5: A = 104 / B= 42 / C = 69 (104 is inserted replacing 32, then swims upwards)

 6: A = 104 / B= 42 / C = 93 (93 is inserted replacing 69, remains there)       

Answer 1

首先，您不能将PriorityQueue 保持排序；如果与堆数据结构不完全相同，它是相似的。
PriorityQueue 只是被授予者顶部元素是 min OR max，因为它是 min OR max heap。

您还对排序元素和查找 K 最大/最小元素这两个不同的问题感到困惑。

如果您想在给定的 N 个元素列表中对元素进行排序：
使用基于比较的排序算法，您无法获得比 O(N*log(N)) 更好的运行时间。

但是，如果您的情况只是从 N 元素列表中查找 K 最小/最大元素：
您可以在 O(N*log(K)) 时间内实现。

请检查此问题一次：Finding the first n largest elements in an array

Answer 2

即使您的 cmets In step 5, 104 and 69 switch places 和 so that after each iteration, the lowest element is at C 也不一致。因为在第 5 步中，最低值 42 位于 B。

也许您正在寻找与此类似的解决方案。

public class FixedCapacityPriorityQueue {

    static class MyPriorityQueue extends PriorityQueue<Integer> {

        private final int capacity;

        public MyPriorityQueue(int capacity) {
            super(capacity, Comparator.reverseOrder());
            this.capacity = capacity;
        }

        @Override
        public boolean add(Integer i) {
            super.add(i);
            if (size() > capacity) {
                Integer lowest = Integer.MAX_VALUE;
                for (Integer next : this) {
                    if (lowest.compareTo(next) > 0) {
                        lowest = next;
                    }
                }
                this.remove(lowest);
            }
            return true;
        }
    }

    public static void main(String[] args) {
        Integer[] stream = {42, 69, 32, 5, 104, 93};

        for (int i = 0; i < stream.length; i++) {
            PriorityQueue queue = new MyPriorityQueue(3);
            System.out.print("added to queue   : ");
            for (int e = 0; e <= i; e++) {
                 System.out.printf("%d ", stream[e]);
                queue.add(stream[e]);
            }
             System.out.println();
            System.out.print("elements in queue: ");
            while (queue.size() > 0) {
                System.out.printf("%d ", queue.poll());
            }
            System.out.printf("%n%n");
        }
    }
}

输出

added to queue   : 42 
elements in queue: 42 

added to queue   : 42 69 
elements in queue: 69 42 

added to queue   : 42 69 32 
elements in queue: 69 42 32 

added to queue   : 42 69 32 5 
elements in queue: 69 42 32 

added to queue   : 42 69 32 5 104 
elements in queue: 104 69 42 

added to queue   : 42 69 32 5 104 93 
elements in queue: 104 93 69 

Answer 3

您可以将数据排列在二叉树中，并通过二叉树搜索找到您想要删除某些内容的最小数字。 二叉树搜索的复杂度是O(log N)，插入元素的复杂度也是O(log N)。

现在谈论您对长度为 k 的队列的约束，您可以转换二叉树并将其存储在长度为 k 的数组中。

您可以查看此链接If I store a binary tree in an array, how do I avoid the wasted space?，了解如何在数组中实现二叉树。