Algorithm to find indexes of k smallest numbers in an array

Question

Consider a situation like the following:

The array amounts keeps track of some statistical amounts:

int[] amounts = { 1, 2, 5, 7, 2, 4, 8, 6 };

It is known that the array will always have a fixed size (in this case 8). What I need to find are the indexes of a given number k of smallest elements:

int   k = 5;
int[] smallest = { 1, 2, 2, 4, 5 };
int[] smallestIndices = { 0, 1, 4, 5, 2 };

I figured I could make use of the Selection Algorithm, but I realized that this re-orders the array, thus returning an incorrect index.

Another idea I came up with was to create an array of tuples of index and value, and sort that array by the tuple value. Then I could extract the indexes of the first k tuples in the sorted array. However, this seems like a wasteful solution that can probably done more easily.

Is there an algorithm that allows me to find the indexes of the k smallest numbers in an array of size n?

• Note that I am not looking for the smallest k numbers, which is already answered by this question. I am looking for their indexes. Thus, this question should not flagged as a duplicate.

Answer 1

Create an array of indexes, i.e. an array [0,n), the sort that by the element located at that index in the primary array. Now all you need to do is take the top elements from the array of indexes.

There is no need use pairs.

Concrete example:

//imports
import static java.util.Comparator.comparing;

//method
public static int[] bottomN(final int[] input, final int n) {
    return IntStream.range(0, input.length)
            .boxed()
            .sorted(comparing(i -> input[i]))
            .mapToInt(i -> i)
            .limit(n)
            .toArray();
}

Usage:

public static void main(String[] args) throws Exception {
    int[] amounts = {1, 2, 5, 7, 2, 4, 8, 6};
    System.out.println(Arrays.toString(bottomN(amounts, 5)));
}

Output:

 [0, 1, 4, 5, 2]

So all we do is take the array [0,1,2,3,4,5,6,8] and then sort it by the value of the element in the input array at the index equal to the current array element. This gives use an array of indexes sorted by their value in the input.

Finally we trim the top n and return it.

Answer 2

If the array size is always small, you can get away with a simpler algorithm, but this should work fast for larger arrays as well. The idea is to put index-value pairs into a heap, then take out k pairs with the smallest values.

public class SmallestIndicesTest {
    public static void main(String[] args) {
        // main method here as an example use case
        int[] amounts = { 1, 2, 5, 7, 2, 4, 8, 6 };
        int k = 5;
        ArrayList<Integer> smallestIndices = getNsmallestIndices(amounts, k);
        for (int i : smallestIndices) {
            System.out.println("Index i=" + i + " contains value " + amounts[i]);
        }
    }

    private static ArrayList<Integer> getNsmallestIndices(int[] t, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        PriorityQueue<Pair> queue = new PriorityQueue<>();
        for (int i=0; i<t.length; i++) {
            queue.add(new Pair(t[i], i));
        }
        for (int i=0; i<k; i++) {
            Pair nextSmallest = queue.poll();
            list.add(nextSmallest.index);
        }
        return list;
    }
}


class Pair implements Comparable<Pair> {
    public int value;
    public int index;

    public Pair(int value, int index) {
        this.value = value;
        this.index = index;
    }

    @Override
    public int compareTo(Pair o) {
        return (this.value - o.value);
    }
}

Answer 3

It depends on the ratio of number of elements to the amount of elements you want to find. You will be able to sort n elements as tuples in in O(n*log(n)). However if the amount of elements (m) you want to find is < log(n), you might consider simply looping through the list and gathering the m smallest elements. Then you will be guaranteed a complexity of O(n*log(n)). If you have a constant amount of elements you want to find, your complexity with the latter method will be O(n).

Answer 4

What you need to do is to keep the index of the elements. For the example you gave,

int[] amounts = { 1, 2, 5, 7, 2, 4, 8, 6 }

Use an array of pair to re-store the array, then you get,

pair<int,int>[] pairs = {{0, 1},{1, 2}, {2, 5}, {3, 7}, {4, 2}, {5, 4}, {6, 8}, {7, 6}}

then apply the selection algorithm on the array of pairs. Note that you should use the second value of the pair as the primary key to compare a pair. You can return the k most smallest values as well as their indexes. The complexity is the same as the selection algorithm.

Answer 5

I am not sure I got your question. You want to get multiple indexes of elements from an array? If so you can try to create a new array and add indexes there, therefore the first element of smallest array is at the index of first element of indexes array. Something like

public static void main(String[] args) {
    int[] amounts = { 1, 2, 5, 7, 2, 4, 8, 6 };
    int   k = 5;
    int[] smallest = { 1, 2, 2, 4, 5 };
    int[] indexes = new int[k];
    for (int i = 0; i<k; i++) {
        int searchable = smallest[i];
        for (int j = 0; j<amounts.length; j++) {
            if (searchable == amounts[j]) {
                indexes[i] = j;
            }
        }
        }           
    for (int n = 0; n<indexes.length; n++) {
            System.out.println("Number " + smallest[n] + " index is " + indexes[n]);
    }
}

Answer 6

You can do this in pretty close to linear time (technically it's O(nk) but based on your description n is small) for any size of n and k, no need to be fancy.

If you are dealing with long lists and worried about cache coherency then you can create an object containing two integers for index and value (you could just use a tuple but an object is cleaner). Create an ArrayList of capacity n initially empty. If not worried about jumping around in memory then just an array of n integers each holding the index and initialized to -1 will suffice. Just look up the value from the index each time.

Loop through the elements of k. For each element

• Check if the value is lower than the last value in the list, if not move to next element and no processing is needed at all on this one.
• If the list length is n then delete the last item from the list to make room for the new one.
• Create a new object with the index and value set. (Only needed if using an object)
• Scan through the ArrayList until you find a smaller object or the start of the list
• Insert the new object (or index) at the located point

At the end of a single scan through the main list the ArrayList will contain a sorted list of the smallest n values.