Find the smallest element in an array

• Linear scan – visit each element exactly once from left to right, giving O(n) time.
• Tracking variable – a single variable min remembers the smallest value seen so far, giving O(1) extra space.
• Seeding – initialise min with the first element, not with a large constant, because that is always correct.
• Comparison – for BigDecimal use compareTo where a negative result means the left value is smaller.
• Mirror of max – the logic is identical to finding the largest element, with the comparison direction flipped.

What is the problem?

Given an array of numbers, find the single smallest element. In a banking context, Priya runs a shop on current account CUR3001 at National Bank of India and wants to know her smallest sale amount of the day to set a minimum order threshold.

Why use a linear scan?

Just like finding the maximum, you cannot skip any element because any skipped element might be the smallest. Sorting first costs O(n log n), which is unnecessary when a single O(n) pass suffices.

How does the algorithm work?

Seed a variable min with the first element. Iterate from the second element to the end. For each element, if it is smaller than min, assign it to min. When the loop finishes, min holds the smallest value.

package com.bank.service;

import java.math.BigDecimal;

public class SaleAnalyzer {

    public static BigDecimal findSmallestSale(BigDecimal[] sales) {
        if (sales == null || sales.length == 0) {
            throw new IllegalArgumentException("No sales to analyze");
        }
        BigDecimal min = sales[0];
        for (int i = 1; i < sales.length; i++) {
            if (sales[i].compareTo(min) < 0) {
                min = sales[i];
            }
        }
        return min;
    }

    public static void main(String[] args) {
        BigDecimal[] dailySales = {
            new BigDecimal("1250.00"),
            new BigDecimal("340.50"),
            new BigDecimal("8900.00"),
            new BigDecimal("125.75"),
            new BigDecimal("4600.00")
        };
        BigDecimal smallest = findSmallestSale(dailySales);
        System.out.println("Smallest sale for CUR3001: Rs." + smallest);
    }
}

Smallest sale for CUR3001: Rs.125.75

Why seed with the first element?

Seeding with a large constant like Integer.MAX_VALUE does not work for BigDecimal because BigDecimal has no predefined maximum constant. Seeding with the first real element is always correct and avoids guessing an upper bound that might be too small for very large banking amounts.

Why use BigDecimal and compareTo?

BigDecimal stores the exact decimal value and avoids the rounding errors of double. The compareTo method returns a negative number when the left value is smaller, zero when equal, and a positive number when larger. Two BigDecimal values with different scales, such as 340.5 and 340.50, are correctly treated as equal by compareTo.

BigDecimal a = new BigDecimal("340.50");
BigDecimal b = new BigDecimal("125.75");
int result = a.compareTo(b); // positive, meaning a > b

What about the empty array edge case?

An empty array has no smallest element. Returning zero would mislead the caller into thinking a zero-rupee sale occurred. Throwing IllegalArgumentException makes the absence explicit.

if (sales == null || sales.length == 0) {
    throw new IllegalArgumentException("No sales to analyze");
}

What is the time and space complexity?

• Time: O(n) because each element is visited exactly once.
• Space: O(1) because only one tracking variable is used.
• The lower bound is O(n) because any skipped element could be the smallest.

What are common mistakes?

The most common mistake is initializing min with zero, which gives a wrong answer when all values are positive. Another mistake is using the > comparison direction instead of <, which would find the maximum instead of the minimum.

// Wrong: seeding with zero when all sales are positive
BigDecimal min = BigDecimal.ZERO; // stays 0, wrong answer

// Wrong: comparing in the wrong direction
if (sales[i].compareTo(min) > 0) { min = sales[i]; } // finds max, not min

// Correct
BigDecimal min = sales[0];
if (sales[i].compareTo(min) < 0) { min = sales[i]; }

How is this different from finding the maximum?

The logic is identical except the comparison direction is flipped. For finding the maximum you check compareTo > 0; for finding the minimum you check compareTo < 0. Both share the same O(n) time, O(1) space, same seeding strategy, and same edge case handling. They can be combined into a single pass that tracks both min and max simultaneously.

| Aspect | Find Max | Find Min |
|---|---|---|
| Comparison | compareTo > 0 | compareTo < 0 |
| Seed | First element | First element |
| Time | O(n) | O(n) |
| Space | O(1) | O(1) |

What should a senior engineer know?

A senior engineer combines finding both min and max into a single pass to avoid scanning the array twice. The pairwise comparison technique processes elements in pairs, comparing them with each other first, then comparing the smaller against min and the larger against max. This reduces comparisons from 2n to roughly 1.5n. For a Priya's merchant dashboard that needs both the smallest and largest sale, one pass through the day's transactions gives both answers.