Java未排序的ArrayList的Doubles，如何获取最大值的索引？

Question

Guys I have an ArrayList which contains approx 3000 double values.

I basically need the ordered indexes of the top 100 doubles in the ArrayList. I am not concerned with the actual values of the top 100, just their indexes in the order of maximum to minimum.

For example if the largest values (from max to min) in the ArrayList are index50, index27 and index96, then I am only concerend with 50, 27, 96, in THAT exact order.

Code for the ArrayList:

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

The resulting set or list of indexes may be contained in ANY data structure which maintains the order of 50, 27, 96, such as an ArrayList or any other collection type.

In Summary:

How do I return the index numbers of the highest 100 values (doubles) in an ArrayList?

Any assistance appreciated guys,

Answer 1

You can add all the value (as key) index (as value) pairs to a TreeMap (or other SortedMap s) SortedMap.values returns the values (ie, the indeces) in the sorted order.

Edit: This will not work if there are duplicates in your list, as the second put will overwrite the previously stored value (index). So the following seems better:

Create Pairs of index and value, add them to a SortedSet (as suggested bu StKiller below), using a Comparator that sorts by value and then by index (to be consistent with equals as the API-doc puts it). Then just take the first 100 pairs, or rather the indeces stored in those.

Edit 2: Actually, you don't really need the pairs, you can use the Comparator for indeces to look up the values ...

Answer 2

I guess Insertion sort runs in O(n^2) time. Use heap sort which runs in O(nlog(n)) time. Use a min heap of 100 nodes. When you iterate over your list compare the value to the root. If it is larger, replace the root and run the heapify algorithm.

After you finish with all the elements, your heap will contain the top 100 elements.

Usage of a proper data structure for the heap will let you keep the indices as well along with the value.

An example might be

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

Answer 3

I would argue that if you only need the top 100 values, why not use an inverted selection sort that cuts off after 100 iterations? Selection sort guarantees that one value will be put into the correct position on each pass, so after 100 runs through the list the top values should be the one you want. I'm sure a more elegant solution exists, but this should be simple to implement.

Answer 4

import java.util.*;

After all this talk of O(thing) for sorting, I thought I should show that actually the insertion sort is the best in this case. The code below shows various suggestions from this page and my own ideas. The relative performances are:

Insert sort: 61 480ns

Object sort: 1 147 538ns

Sorted set: 671 007ns

Limited set: 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;
    }
}

Answer 5

Use insertion sort. This can be done in O(n^2). Maintain an List which holds the top 100 values of the ArrayList you have. Loop through the ArrayList you have and use Insertion sort to place top elements in the new ArrayList.

Answer 6

In a language like scala you could simply use zipWithIndex , sortWith , take (n) and 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)

However, in Java you have to do more boilerplate code, if calling scala (which is 100% compatible to java) is no option.

However, a nearly as simple solution could be possible with functional java (see API, List).