Find the Largest and Smallest Element in an Array

• Single pass – iterate once from left to right, tracking both the maximum and minimum simultaneously.
• Two trackers – initialise both max and min with the first element of the array.
• O(n) time – each element is visited once, with two comparisons per element.
• O(1) space – only two tracking variables are needed.
• Better than sorting – sorting costs O(n log n) and is overkill when only two values are needed.

What is the problem?

Given an array, find both the largest and smallest elements. In a banking context, the fraud desk at National Bank of India wants both the biggest transaction (possible large unauthorised transfer) and the smallest transaction (possible test transaction before fraud) on Rajesh's account today.

How does the single-pass algorithm work?

Guard the empty case first. For a non-empty array, initialise both max and min to the first element. Then loop from the second element to the end, comparing each element against both trackers.

package com.bank.service;

import java.math.BigDecimal;

public class FraudScreener {

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

    public static void main(String[] args) {
        BigDecimal[] dayTxns = {
            new BigDecimal("15000.00"),
            new BigDecimal("42500.75"),
            new BigDecimal("1.00"),
            new BigDecimal("67200.50"),
            new BigDecimal("3100.25")
        };
        BigDecimal[] result = findMinMax(dayTxns);
        System.out.println("Smallest: Rs." + result[0]);
        System.out.println("Largest:  Rs." + result[1]);
    }
}

Smallest: Rs.1.00
Largest:  Rs.67200.50

Why seed with the first element?

Seeding with zero fails when all amounts are negative (debit-only view). Seeding with Integer.MIN_VALUE and Integer.MAX_VALUE does not apply to BigDecimal, which has no such constants. The first real element is always a safe seed.

Why is one pass better than sorting?

Sorting the array and picking the first and last elements works, but costs O(n log n). The single-pass approach is O(n), which is strictly faster. It also does not modify the array, while sorting would reorder it.

What is the pairwise comparison optimisation?

The naive approach does two comparisons per element (against max and against min), totalling 2(n-1) comparisons. The pairwise technique processes elements in pairs: compare the pair with each other, then compare the smaller against min and the larger against max. This does 3 comparisons per 2 elements, reducing the total to roughly 1.5n.

// Pairwise optimisation sketch
for (int i = 1; i < amounts.length - 1; i += 2) {
    BigDecimal smaller, larger;
    if (amounts[i].compareTo(amounts[i + 1]) < 0) {
        smaller = amounts[i];
        larger = amounts[i + 1];
    } else {
        smaller = amounts[i + 1];
        larger = amounts[i];
    }
    if (smaller.compareTo(min) < 0) min = smaller;
    if (larger.compareTo(max) > 0) max = larger;
}
// Handle last element if array length is even

What about the empty array?

An empty array has no largest or smallest. Returning zeros would mislead the fraud desk. Throwing IllegalArgumentException makes the absence explicit and forces the caller to handle it.

What is the time and space complexity?

• Time: O(n) because each element is visited once.
• Space: O(1) because only two tracking variables are used.
• The pairwise optimisation reduces the constant factor but not the big-O class.

What are common mistakes?

The most common mistake is scanning the array twice, once for max and once for min, which doubles the work unnecessarily. Another mistake is seeding min with zero and max with zero, which fails when all values are negative or all are larger than zero.

// Wrong: two passes
BigDecimal max = findMax(amounts); // O(n)
BigDecimal min = findMin(amounts); // O(n) again, total 2n

// Correct: one pass
// Track both in the same loop as shown above

What should a senior engineer know?

A senior engineer returns both results together in an immutable result object or a two-element array rather than making the caller call two separate methods. For very large distributed datasets, the scan parallelises trivially because each partition finds its local min and max, and the global min/max is the min of local mins and max of local maxes. In the fraud screening pipeline at National Bank of India, this partition-and-merge strategy runs across multiple threads on a day's worth of millions of transactions.