哪种 Map/Array-Datatype 最适合在 Java 中存储和排序值对？

Question

在 Java 中，我有一个动态的（大小：例如 5-45）值对（double、int）列表。我想按第一个双值（不是唯一的！）对列表进行降序排序，并获得第二个 int 值的排序列表。

例如：

input:
0.245  3654
-0.12  7466
0.421  2551
-0.12  1882
0.637  3662
-0.35  5221
0.421  6332

sorted:
0.637  3662
0.421  2551
0.421  6332
0.245  3654
-0.12  7466
-0.12  1882
-0.35  5221

我想要一个普通的 ArrayList，例如：3662 2551 6332 3654 7466 1882 5221

是否有一些相同的双值并不重要；先到先得。

我不能使用排序的 TreeMap，因为第一个值 (double) 不是唯一的。其他 HashMaps/LinkedLists/ArrayLists/Arrays 呢？ 我手动尝试（在一个循环中，比较所有值并保留 2 个列表），它有效，但速度很慢。我也尝试了 2d Array double[][] （但它们的长度必须是固定的，而且我在某处得到了一些空指针）。

我需要：高排序性能，并且 - 如果可能 - 不需要额外的框架（例如 MultiMap）在您看来最优雅和最快的方式是什么？

这是我自己的初学者风格（但这太慢了！！）：

pair-value is: e m

for (...kind of a loop...){
    e = method.get(....);
    m = method.get(....);
                            if (eList.isEmpty()) {
                                eList.add(e);
                                rList.add(m);
                            } else {
                                higher = false;
                                for (int i = 0; i < eList.size(); i++) {
                                    if (e >= eList.get(i)) {
                                        eList.add(i, e);
                                        rList.add(i, m);
                                        higher = true;
                                        break;
                                    }
                                }
                                if (!higher) {
                                    eList.add(e);
                                    rList.add(m);
                                }
}

Answer 1

非常感谢您提出的许多好的建议。我简单地尝试了所有这些，但我不得不说我的第一个算法实际上是最快的（我很惊讶可以在迭代列表时扩展它）。这是关于我自己编写的 JAVA 国际象棋程序，我对此感到非常自豪，我想根据个人着法的评分来排序一个着法列表。那么搜索应该会更快，或者你可以切断不重要的动作。 现在你明白了为什么我要找的这段代码必须这么快。由于递归和大深度，每一纳秒都被取幂。所以我可以测量到 TreeMap 慢了 30%：-o !! 与比较器相关的配对对象也慢了大约 35%。 因此我的问题又来了：我可以让我上面的方法（使用手动循环）更快吗？

Answer 2

您认为最优雅、最快捷的方式是什么？

在我看来，最优雅和最快的方法是使用TreeMap<Double, List<Integer>>。这将是一个使用内置 Java 功能的multimap。

来自

input:
0.245  3654
-0.12  7466
0.421  2551
-0.12  1882
0.637  3662
-0.35  5221
0.421  6332

你有TreeMap<Double, List<Integer>>

0.637 = {3662}
0.421 = {2551,6332}
0.245 = {3654}
-0.12 = {7466,1882}
-0.35 = {5221}

例如使用

  for (Pair<Integer, Double> pair : list) {
     Double score= pair.getValue();
     treeMap.putIfAbsent(score, new ArrayList<>());
     treeMap.get(score).add(pair.getKey());
  } 

然后你可以迭代并生成普通的ArrayList，例如：{3662 2551 6332 3654 7466 1882 5221}，例如

List<Integer> result = new ArrayList<>();
for (List<Integer> list : map.values()) {
    result.addAll(list);
} 

Answer 3

另一种方法是创建一个包含double 和int 值的Pair 类

     class Pair {
        private Double doubleVal;
        private Integer intVal;

        public Pair(Double doubleVal, Integer intVal) {
            this.doubleVal = doubleVal;
            this.intVal = intVal;
        }

        public double getDoubleVal() {
            return doubleVal;
        }

        public int getIntVal() {
            return intVal;
        }
    }

并在List<Pair> 中收集输入

List<Pair> pairs = Arrays
            .asList(new Pair(0.245, 3654), new Pair(-0.12, 7466), /*further elements*/);

现在，Collections.sort() 可以通过提供所需的Comparator 来使用，例如：

Collections.sort(pairs, Comparator.comparingDouble(Pair::getDoubleVal).reversed());

这将根据double 值按降序对pairs 集合进行排序。就排序性能而言，Collections.sort() 使用Tim Sort（我正在运行 zulu JDK8。因此默认使用此排序算法）在最坏的情况下以O(nlogn) 运行。

这样，可以得到一个像{3662 2551 6332 3654 7466 1882 5221}这样的普通数组列表

pairs.stream().map(Pair::getIntVal).collect(Collectors.toList())