相关疑难解决方法(0)

我如何得到一个PriorityQueue排序我希望它排序的东西？

另外,offer和add方法之间有区别吗？

我需要一个比较器作为策略模式的一部分,可以使用对象的自然顺序或一些自定义顺序.对于自然排序的情况,我写了一个简单的比较器:

private static class NaturalComparator<T extends Comparable<? super T>> implements Comparator<T> {
    @Override
    public int compare(T o1, T o2) {
        return o1.compareTo(o2);
    }
}

看起来很简单,但我想知道是否有人知道标准API中的一个.我查看了TreeMap,它没有这样的类,所以当编写代码时,明显的答案是否定的,但也许稍后会添加.

我正在计算一个algortihm的大量可能的结果组合.要对这些组合进行排序,我使用双倍值对它们进行评级,并将它们存储在PriorityQueue中.目前,该队列中有大约20万个项目,这几乎是内存集成.实际上,我只需要说出列表中所有项目中最好的1000或100.所以我开始问自己是否有办法在Java中拥有一个固定大小的优先级队列.我的行为应该是这样的:物品是否比已存储的物品更好？如果是,请将其插入相应的位置并抛出最小等级的元素.

有没有人有想法？再次感谢!

马尔科

我最近在面试期间进行了编码测试。有人告诉我：

有一个一百万个的大型未排序数组int。用户想要检索K最大的元素。你会实现什么算法？

在此期间，我强烈暗示我需要对数组进行排序。

因此，如果性能确实很重要，我建议使用内置sort()或自定义实现。然后我被告知，使用Collectionor数组来存储k最大的元素和 for 循环可以实现大约O(N)，事后看来，我认为这是O(N*k)因为每次迭代都需要与大小数组进行比较K以找到要替换的最小元素，而需要对数组进行排序将导致代码至少为O(N log N).

然后我回顾了 SO 上的这个链接，它建议K数字的优先级队列，每次找到较大的元素时删除最小的数字，这也会给出O(N log N). 编写一个程序，从 10 亿个数字的数组中找出 100 个最大的数字

for循环方法不好吗？我应该如何证明使用 for 循环或优先级队列/排序方法的优点/缺点？我认为，如果数组已经排序，则不需要再次迭代整个数组，即如果对排序数组调用其他检索方法，则它应该是恒定时间。运行实际代码时是否存在一些我在理论化伪代码时没有考虑到的性能因素？

似乎它们都让你检索最小值,这是我对Prim算法所需要的,并强制我删除并重新插入一个键来更新它的值.使用一个优于另一个是否有任何优势,不仅仅是这个例子,但一般来说？

这是我的代码,用于查找数字数组中的最大数字,但我似乎无法理解如何获取前5个数字并将它们存储在数组中,然后检索它们

这是代码:

public class Max {


    public static void main (String[] args) 
    {
        int i;
        int large[]=new int[5];     
        int array[] = {33,55,13,46,87,42,10,34,43,56};
        int max = array[0]; // Assume array[0] to be the max for time-being

        //Looping n-1 times, O(n)
        for(  i = 1; i < array.length; i++) // Iterate through the First Index and compare with max
        {
            // O(1)
            if( max < array[i])
            {
                // O(1)
                max = array[i];// Change max if condition is True
                large[i] = max;
            } …

我正在寻找一个集合:

• 是Deque/ List- 即支持在"顶部"插入元素(最新项目到顶部) - deque.addFirst(..)/ list.add(0, ..).它可能是a Queue,但是迭代顺序应该是反向的 - 即最近添加的项应该首先出现.
• 是有界的 - 即限制20项
• 达到容量时,自动丢弃最旧的项目("在底部",最先添加)
• 非阻塞 - 如果双端队列为空,则检索不应阻止.它也应该不会阻塞/返回false/null/throw异常是deque已满.
• 并发 - 多个线程应该能够对它进行操作

我可以LinkedBlockingDeque把它包装到我的自定义集合中,在add操作检查大小并丢弃最后一个项目时.有更好的选择吗？

我有一些对象.我需要从Set中获取两个min对象.

我的例子如下:

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Example {
     public static void main( String[] args ) {
         SomeObject obj1 = new SomeObject(1);
         SomeObject obj2 = new SomeObject(2);
         SomeObject obj3 = new SomeObject(3);
         Set<SomeObject> set = Stream.of(obj1,obj2,obj3)
                                     .collect(Collectors.toSet());

         SomeObject minObject= set.stream()
                                  .min(Comparator.comparingInt(object->object.getValue()))
                                  .get();
         System.out.println(minObject);
     }
}


class SomeObject{
    private int value;
    SomeObject(int value){
            this.value=value;
    }

    public int getValue() {
        return value;
    }

    @Override
    public String toString() {
        return this.value+"";
    }
}

在我的例子中,我可以根据value属性从这个Set中获取min对象.

所以,我需要使用java流操作获取两个最小值.

awnser应该很快,因为在我的真实程序中,我多次调用此方法,我的集合非常大.

如何删除优先级队列的尾部元素？我正在尝试使用优先级队列实现波束搜索,一旦优先级队列已满,我想删除最后一个元素(具有最低优先级的元素).

谢谢!

我有一个类,我想在scala.collection.mutable.PriorityQueue中使用,但我不想让它为了这个目的而订购[A].我不认为我想要使用的顺序是PriorityQueue作为类的自然顺序.

class MyObject (sequence: Int, values: List[String]) ...

所以,在我的PriorityQueue中,我希望这些值按'sequence'排序.然而,仅仅因为两个对象具有相同的序列并不能使它们自然相等,因为它们的"值"的内容可能不同.

这就是在Java中,能够为PriorityQueue提供备用Comparator对象的好处.我的比较器只是根据它们的"序列"对对象进行排序,并忽略它们的"值".

必须使用"A <%Ordered [A]"参数化PriorityQueue类

class PriorityQueue[A <% Ordered[A]] extends ... 

从我所读到的,这意味着我的班级必须扩展Ordered [A]或者我必须提供一个"隐式def"类型转换为Ordered [A],老实说,它感觉不优雅.

Java解决方案似乎更具"功能性",允许我传递一个类似Comparator函数的对象,而不是强迫我进入类层次结构或monkeypatching我的类.

我意识到有使用PrioirityQueue的替代方案,但我觉得我可能会在这里遇到Scala学习曲线,并且不想在没有完全探索这个设计决策的情况下放弃.

这只是Scala库中的一个不幸的决定,还是我误解了某种调用约定,使PriorityQueue更具可用性和"功能性"？

谢谢