Finding The Index of the Smallest Element in an Array

1. Overview

Operations on arrays are essential, and we might need them in any application. Sometimes, they’re hidden behind more convenient interfaces like Collections API. However, this is the basic knowledge we should acquire early in our careers.

In this tutorial, we’ll learn how to find the index of the smallest element in an array. We’ll discuss the methods to do so regardless of the types of the elements, but for simplicity, we’ll use an array of integers.

2. Simple Iteration

The simplest solution is often the best one. This is true for several reasons: it’s easier to implement, change, and understand. Thus, let’s check how we can find the index of the smallest element using a basic for loop:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingForLoop_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Integer.MAX_VALUE;
    int minIndex = -1;
    for (int i = 0; i < array.length; i++) {
        if (array[i] < minValue) {
            minValue = array[i];
            minIndex = i;
        }
    }
    assertThat(minIndex).isEqualTo(expectedIndex);
}

The implementation is quite verbose. However, we aim to resolve the problem and not minimize the number of lines we use. This is a robust and simple solution that is easy to read and change. Also, it doesn’t require a deep understanding of more advanced Java APIs.

The for loop can be replaced by while or, if we feel especially fancy, even do-while. The method we use to iterate over an array isn’t very important.

At the same time, if we’re working with reference types, we can apply this logic only to comparable objects, and instead of the < operator, use the compareTo() method.

3. Two-Step Approach

In another approach, we can split the task into two separate steps: finding the smallest element and finding its index. Although it would be less performant than the first one, it still has the same time complexity.

Let’s modify our first approach:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingForLoopAndLookForIndex_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Integer.MAX_VALUE;
    for (int number : array) {
        if (number < minValue) {
            minValue = number;
        }
    }
    int minIndex = -1;
    for (int i = 0; i < array.length; i++) {
        if (array[i] == minValue) {
            minIndex = i;
            break;
        }
    }
    assertThat(minIndex).isEqualTo(expectedIndex);
}

Here, we need to use two separate loops. At the same time, we can simplify the first one, as we don’t need the index and may break out of the second one earlier. Please note that it doesn’t improve performance compared to the first approach.

4. Primitive Streams

We can eliminate the first loop from the previous approach. In this case, we can use Stream API and, in particular, IntStream:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingIntStreamAndLookForIndex_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
    int minIndex = -1;
    for (int i = 0; i < array.length; i++) {
        if (array[i] == minValue) {
            minIndex = i;
            break;
        }
    }
    assertThat(minIndex).isEqualTo(expectedIndex);
}

IntStreams provide convenient methods for operations on a sequence of primitive values. We used the min() method and converted our imperative loop into a declarative stream.

Let’s try to refactor the second loop into a declarative one:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingIntStreamAndLookForIndexWithIntStream_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
    int minIndex = IntStream.range(0, array.length)
      .filter(index -> array[index] == minValue)
      .findFirst().orElse(-1);
    assertThat(minIndex).isEqualTo(expectedIndex);
}

In this case, we used IntStream.range() for iteration and compared the element to the minimal one. This approach is declarative and should be considered as the way to go. However, the readability of the code suffered, especially for developers with little experience with streams.

We can replace the logic to find the smallest element with a one-liner using the Apache Commons ArrayUtils class:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingIntStreamAndLookForIndexWithArrayUtils_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
    int minIndex = ArrayUtils.indexOf(array, minValue);
    assertThat(minIndex).isEqualTo(expectedIndex);
}

This makes the solution more readable but requires additional dependencies. If we don’t want to add more dependencies, we can use Lists, as they contain the indexOf() method by default:

@ParameterizedTest
@MethodSource("referenceTypesProvider")
void givenArray_whenUsingReduceAndList_thenGetCorrectResult(Integer[] array, int expectedIndex) {
    List<Integer> list = Arrays.asList(array);
    int minValue = list.stream().reduce(Integer.MAX_VALUE, Integer::min);
    int index = list.indexOf(minValue);
    assertThat(index).isEqualTo(expectedIndex);
}

However, converting an array to a List would affect the space complexity of our solution, increasing it from constant to linear. We won’t consider this approach in further examples, as it doesn’t provide any significant benefits.

5. Arrays and Reference Types

While primitive streams provide a nice API for computations, they’re not applicable for reference types. In this case, we can use the reduce() method:

@ParameterizedTest
@MethodSource("referenceTypesProvider")
void givenArray_whenUsingReduce_thenGetCorrectResult(Integer[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).reduce(Integer.MAX_VALUE, Integer::min);
    int minIndex = ArrayUtils.indexOf(array, minValue);
    assertThat(minIndex).isEqualTo(expectedIndex);
}

The reduce() method takes the identified value; in our case, it’s the Integer.MAX_VALUE and the method reference to the min() method. We use the reduce() method somewhat unconventionally, filtering instead of aggregating. Here, we used ArrayUtils, but the solution with a for loop or filter() would also work.

6. Indexes in Streams

We can use indexes directly with the Stream solution as we did previously with filter(). This way, we can do all the logic inside the reduce() method:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingReduceWithRange_thenGetCorrectResult(int[] array, int expectedIndex) {
    int index = IntStream.range(0, array.length)
      .reduce((a, b) -> array[a] <= array[b] ? a : b)
      .orElse(-1);
    assertThat(index).isEqualTo(expectedIndex);
}

We pass the index of the smallest element along the stream. However, this approach might not be readable and requires a deeper knowledge of the Stream API.

7. Conclusion

Arrays are the most basic data structures in Java. Being comfortable with manipulating and iterating them is a valuable skill, though we don’t usually use arrays directly.

The most straightforward approach is usually the best, as it’s understandable and explicit. Using Streams requires a deeper knowledge of functional programming and might affect the readability of the code in both ways: better or worse. Thus, Stream API should be used with caution.

As usual, all the code from the article is available over on GitHub.