【问题标题】:Java unsorted ArrayList of Doubles, how to get indexes of highest values?Java unsorted ArrayList of Doubles,如何获取最高值的索引?
【发布时间】:2011-04-07 20:19:57
【问题描述】:

伙计们,我有一个包含大约 3000 个双精度值的 ArrayList。

我基本上需要 ArrayList 中前 100 个双精度数的有序索引。 我不关心前 100 名的实际值,只关心它们的索引从最大值到最小值。

例如,如果 ArrayList 中的最大值(从 max 到 min)是 index50、index27 和 index96,那么我只关心 50、27、96,按照那个确切的顺序。

ArrayList 的代码:

ArrayList<Double> ids   = new ArrayList<Double>();

结果集或索引列表可以包含在任何保持 50、27、96 顺序的数据结构中,例如 ArrayList 或任何其他集合类型。

总结:

如何返回 ArrayList 中最高 100 个值(双精度值)的索引号?

感谢任何帮助,

【问题讨论】:

  • 双精度值是否唯一?如果不是,您如何指定哪个索引对于两个相同数字具有更高的值?
  • 是的,它包含重复值。重复应按任何顺序返回。例如,如果所有元素都包含 1.0,那么这些元素将按任意顺序返回。干杯....
  • 哇,到目前为止,三个答案完全忽略了需要索引而不是值的部分。 :(

标签: java arraylist


【解决方案1】:
import java.util.*;

在所有关于排序 O(thing) 的讨论之后,我想我应该表明实际上插入排序在这种情况下是最好的。下面的代码显示了这个页面的各种建议和我自己的想法。相对表现如下:

插入排序:61 480ns

对象排序:1 147 538ns

排序集:671 007ns

限定组:435 130ns

public class DoubleIndexSort {

    static class DI implements Comparable<DI> {
        final int index;

        final double val;


        DI(double v, int i) {
            val = v;
            index = i;
        }


        public int compareTo(DI other) {
            if (val < other.val) {
                return 1;
            } else if (val == other.val) {
                return 0;
            }
            return -1;
        }
    }



    public static void checkResult(double[] test, int[] indexes) {
        for(int i = 0;i < indexes.length;i++) {
            int ii = indexes[i];
            double iv = test[ii];
            // System.out.println("Checking " + i + " -> " + ii + " = " + iv);
            for(int j = 0;j < test.length;j++) {
                // System.out.println(j + " -> " + test[j]);
                if (j != ii && test[j] > iv) throw new RuntimeException();
            }
            test[ii] = -1;
        }
    }


    public static int[] getHighestIndexes(double[] data, int topN) {
        if (data.length <= topN) {
            return sequence(topN);
        }
        int[] bestIndex = new int[topN];
        double[] bestVals = new double[topN];

        bestIndex[0] = 0;
        bestVals[0] = data[0];

        for(int i = 1;i < topN;i++) {
            int j = i;
            while( (j > 0) && (bestVals[j - 1] < data[i]) ) {
                bestIndex[j] = bestIndex[j - 1];
                bestVals[j] = bestVals[j - 1];
                j--;
            }
            bestVals[j] = data[i];
            bestIndex[j] = i;
        }

        for(int i = topN;i < data.length;i++) {
            if (bestVals[topN - 1] < data[i]) {
                int j = topN - 1;
                while( (j > 0) && (bestVals[j - 1] < data[i]) ) {
                    bestIndex[j] = bestIndex[j - 1];
                    bestVals[j] = bestVals[j - 1];
                    j--;
                }
                bestVals[j] = data[i];
                bestIndex[j] = i;
            }
        }

        return bestIndex;
    }


    public static int[] getHighestIndexes2(double[] data, int topN) {
        if (data.length <= topN) {
            return sequence(topN);
        }
        DI[] di = new DI[data.length];
        for(int i = 0;i < data.length;i++) {
            di[i] = new DI(data[i], i);
        }
        Arrays.sort(di);        

        int[] res = new int[topN];
        for(int i = 0;i < topN;i++) {
            res[i] = di[i].index;
        }
        return res;
    }


    public static int[] getHighestIndexes3(double[] data, int topN) {
        if (data.length <= topN) {
            return sequence(topN);
        }
        SortedSet<DI> set = new TreeSet<DI>();
        for(int i=0;i<data.length;i++) {
            set.add(new DI(data[i],i));
        }
        Iterator<DI> iter = set.iterator();
        int[] res = new int[topN];
        for(int i = 0;i < topN;i++) {
            res[i] = iter.next().index;
        }
        return res;
    }


    public static int[] getHighestIndexes4(double[] data, int topN) {
        if (data.length <= topN) {
            return sequence(topN);
        }
        SortedSet<DI> set = new TreeSet<DI>();
        for(int i=0;i<data.length;i++) {
            set.add(new DI(data[i],i));
            if( set.size() > topN ) {
                set.remove(set.last());
            }
        }
        Iterator<DI> iter = set.iterator();
        int[] res = new int[topN];
        for(int i = 0;i < topN;i++) {
            res[i] = iter.next().index;
        }
        return res;
    }


    /**
     * @param args
     */
    public static void main(String[] args) {
        long elap1 = 0;
        long elap2 = 0;
        long elap3 = 0;
        long elap4 = 0;
        for(int i = 1;i <= 1000;i++) {
            double[] data = testData();
            long now = System.nanoTime();
            int[] inds = getHighestIndexes(data, 100);
            elap1 += System.nanoTime() - now;
            checkResult(data, inds);
            System.out.println("\nInsert sort: "+(elap1 / i));

            now = System.nanoTime();
            inds = getHighestIndexes2(data, 100);
            elap2 += System.nanoTime() - now;
            checkResult(data, inds);
            System.out.println("Object sort: "+(elap2 / i));

            now = System.nanoTime();
            inds = getHighestIndexes3(data, 100);
            elap3 += System.nanoTime() - now;
            checkResult(data, inds);
            System.out.println("Sorted set:  "+(elap3 / i));

            now = System.nanoTime();
            inds = getHighestIndexes4(data, 100);
            elap4 += System.nanoTime() - now;
            checkResult(data, inds);
            System.out.println("Limited set: "+(elap4 / i));
        }
    }


    private static int[] sequence(int n) {
        int[] indexes = new int[n];
        for(int i = 0;i < n;i++) {
            indexes[i] = i;
        }
        return indexes;
    }


    public static double[] testData() {
        double[] test = new double[3000];
        for(int i = 0;i < test.length;i++) {
            test[i] = Math.random();
        }
        return test;
    }
}

【讨论】:

  • 运行时顺序只是决定的一个因素。 getHighestIndexes() 比一些较慢的解决方案复杂得多,需要更多的时间来编写和测试。由于开发人员的时间比 CPU 时间更昂贵,这是一个很大的部分。顺便说一句,getHighestIndexes() 对于 100 个或更少值的列表会失败。
【解决方案2】:

我猜插入排序在 O(n^2) 时间内运行。使用在 O(nlog(n)) 时间内运行的堆排序。使用 100 个节点的最小堆。当您遍历列表时,将值与根进行比较。如果比较大,换根,运行heapify算法。

完成所有元素后,您的堆将包含前 100 个元素。

为堆使用适当的数据结构可以让您将索引与值一起保留。

一个例子可能是

class MinHeapNode
{
    public int value;
    public int index;
    public MinHeapNode left;
    public MinHeapNode right;
}

【讨论】:

    【解决方案3】:

    我认为,如果您只需要前 100 个值,为什么不使用在 100 次迭代后中断的反向选择排序?选择排序保证每次遍历都会将一个值放入正确的位置,因此在列表中运行 100 次后,最高值应该是您想要的值。我确信存在更优雅的解决方案,但这应该很容易实现。

    【讨论】:

    • 哦,我忽略了问题的索引部分。
    • 显然 OP 也这样做了 ;-)
    【解决方案4】:

    您可以将所有值(作为键)索引(作为值)对添加到 TreeMap(或其他 SortedMaps) SortedMap.values 按排序顺序返回值(即索引)。

    编辑:如果您的列表中有重复项,这将不起作用,因为第二个 put 将覆盖先前存储的值(索引)。所以以下似乎更好:

    创建索引和值对,将它们添加到 SortedSet(如下面的 StKiller 建议),使用按值排序的 Comparator,然后按索引(作为 API与 equals 一致 -doc 说的)。然后只取前 100 对,或者更确切地说是存储在其中的索引。

    编辑 2: 实际上,您并不需要这些对,您可以使用 Comparator for indeces 来查找值...

    【讨论】:

    • 使用 TreeSet 不是更好吗?它使用同一棵树进行排序,并且只存储唯一值。
    • 我很确定 DJDonna 想要保留重复值。
    • 一个 Set 将只包含值,但 DJDonaL3000 正在寻找索引...但是,您提醒我,如果某些值相同,TreeMap 没有帮助。
    【解决方案5】:

    使用插入排序。这可以在 O(n^2) 中完成。维护一个包含您拥有的 ArrayList 的前 100 个值的列表。循环遍历您拥有的 ArrayList 并使用插入排序将顶部元素放置在新的 ArrayList 中。

    【讨论】:

    • 仅当列表已按正确顺序排序时,插入排序为 O(n)。在一般情况下它是 O(n^2),尽管您可以在执行插入时使用二进制搜索来使 O(n log n)。无论如何,这只会产生 100 个最大值,而不是 DJDonaL3000 想要的索引。
    • @David Harkness,我意识到了这一点并做出了改变。感谢您指出这一点。
    【解决方案6】:

    在像 scala 这样的语言中,您可以简单地使用 zipWithIndex、sortWith、take (n) 和 map:

    val ids = List (2.0, 2.5, 1.5, 0.5, 7.5, 7.0, 1.0, 8.0, 4.0, 1.0);
    ids.zipWithIndex.sortWith ((x, y) => (x._1 >  y._1)).take (3).map (vi => vi._2)
    res65: List[Int] = List(7, 4, 5)
    

    但是,在 Java 中,如果无法调用 scala(与 Java 100% 兼容),则必须编写更多样板代码。

    但是,使用functional java 可以实现几乎同样简单的解决方案(请参阅 API,列表)。

    【讨论】:

      猜你喜欢
      • 2016-07-26
      • 1970-01-01
      • 1970-01-01
      • 2016-08-20
      • 2019-06-02
      • 2014-12-23
      • 1970-01-01
      • 1970-01-01
      • 2016-02-01
      相关资源
      最近更新 更多