使用自定义比较器在 O(n) 中创建 PriorityQueue

Question

我正在尝试使用带有自定义比较器的 Priorityqueue 实现 MST，但是在 O(n) 时间内使用它构建最小堆时遇到了问题。问题是 Priorityqueue 只有一个构造函数允许在 O(n) 中创建 PriorityQueue，但它不接受任何比较器作为参数。我希望它使用我的自定义比较器。这个问题有解决方法吗？ PriorityQueue.addAll() 将失去使用 MST 的最小堆的目的，因为它是 O(nlogn) 方法。这是我的代码。

ArrayList <edge>ar=new ArrayList<>(); 
   for(int i=0;i<e;i++)
   {
       int u=ss.nextInt();
       int v=ss.nextInt();
       int w=ss.nextInt();
       ar.add(new edge(u,v,w));
   }
   PriorityQueue <edge>pr=new PriorityQueue<edge>(ar);

还有我要使用的比较器：-

PriorityQueue <edge>ar=new PriorityQueue(11,new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            edge n1=(edge) o1;
            edge n2=(edge) o2;
            if(n1.w<n2.w)
            {
                return -1;
            }
            else if(n1.w==n2.w)
            {
                if((n1.u+n1.v+n1.w)<=(n2.u+n2.v+n2.w))
                {
                    return -1;
                }   
                else
                {
                    return 1;
                }
            }
            else
            {
                return 1;
            }
        }
    });

Answer 1

如果你没有在其他地方对你的列表进行最小堆排序，你将无法new PriorityQueue(...) 任何东西，并以某种方式避免创建堆的影响。 here 的数学运算表明它是平均情况下的 O(n)，但它仍然不仅仅是迭代。

PriorityQueue<edge> pr = new PriorityQueue<edge>(ar, comp) {
    PriorityQueue(List<edge> ar, Comparator<edge> c) {
        this(c);
        for(int i = 0; i < queue.length; i++) {
            queue[i] = ar.get(i);
        }
        this.size = queue.length;
        heapify(); // O(n), except that heapify is private and thus you can't call it!!!
    }
}

现在我还没有对此进行测试，在 PriorityQueue 源的一些指导下，它只是在我脑海中浮现，但它应该为您指明正确的方向。

但有时您必须向 piper 付费并创建堆顺序，而这不仅仅是迭代。不过，它应该仍然在O(n)，因为heapify。

另一种选择是让edge 实现Comparable<edge>。然后你就可以PriorityQueue<edge> pr = new PriorityQueue(ar);

如果您无法控制edge implements Comparable<edge>，那么您可以编写一个容器类：

class EdgeContainer implements Comparable<EdgeContainer> {

    private static final Comparator<edge> comp = ; // that comparator above
    private final edge edge;
    EdgeContainer(Edge edge) { this.edge = edge; }
    public int compareTo(EdgeContainer e) { return comp.compare(edge, e.edge); }
    public edge getEdge() { return edge; }
}

List <EdgeContainer>ar=new ArrayList<>(); 
for(int i=0;i<e;i++)
{
   int u=ss.nextInt();
   int v=ss.nextInt();
   int w=ss.nextInt();
   ar.add(new EdgeContainer(new edge(u,v,w)));
}

PriorityQueue<EdgeContainer> qr = new PriorityQueue(ar);

Answer 2

Java 的PriorityQueue 需要 O(n) 时间从传递给它的集合中创建一个优先级队列。数学证明已在 CLSR 第 6.4 章（第 3 版第 157 页）中给出。直观地说，随着使用siftDown 或siftUp 将底层数组变异为堆，为下一次sift 操作循环的元素数量的大小也会减小，从而导致 O(n) 时间复杂度。

但正如 cmets 中所讨论的以及您在问题中提到的那样，您无法通过使用 addAll() 来实现这种时间复杂度。原因是 adAll() 继承自 AbstractQueue 并通过将集合中的元素一一添加到队列中来工作，这可能导致 O(nlogn) 时间复杂度。

因此，如果绝对要求具有 O(n) 时间复杂度，您将别无选择，只能为集合中包含的对象类实现 Comparator 接口。 @corsiKa 的回答很好地详细说明了这种方法。另请注意，即使您将集合直接传递给PriorityQueue，它也会将其转换为数组，这基本上是另一个 O(n) 操作。