Find Maximum and Minimum in Array using Loop - Algorithm and Examples

Arrays

Contents

VisualizationProblemExamplesSolutionAlgorithmCodeTimeSpaceDetailed Ex

Visualization Player

Problem Statement❯

Given an array of integers, your task is to find the maximum and minimum values present in the array using a simple loop (without any built-in functions).

  • The maximum value is the largest number in the array.
  • The minimum value is the smallest number in the array.

If the array is empty, there is no maximum or minimum, and the result should indicate that appropriately (e.g., null or a message).

Examples❯

Input Array Maximum Minimum Description
[10, 20, 5, 8, 30] 30 5 Normal case with unordered elements Visualization
[5, 5, 5, 5] 5 5 All elements are equalVisualization
[-10, -5, -3, -20] -3 -20 All elements are negativeVisualization
[100] 100 100 Only one element in the arrayVisualization
[] null null Empty array — no max or min can be determinedVisualization

Solution❯

Understanding the Problem

We are given an array of numbers and asked to find the maximum and minimum values. This is a basic but important problem that teaches us how to scan through data and compare values step-by-step. Let's walk through how we can solve it efficiently, using a beginner-friendly approach.

Step-by-Step Approach

Step 1: Start With the First Element

We begin by assuming the first element of the array is both the maximum and minimum. This gives us a starting point for comparison.

Step 2: Loop Through the Array

Go through each element in the array one by one:

  • If the current element is greater than the current maximum, update the maximum.
  • If the current element is less than the current minimum, update the minimum.

This way, you’ll always keep track of the biggest and smallest values you’ve seen so far.

Example: [4, 2, 9, 1, 6]

Let’s walk through the example step-by-step:

  1. Start with max = 4 and min = 4.
  2. Compare 2 → smaller than min → update min = 2
  3. Compare 9 → greater than max → update max = 9
  4. Compare 1 → smaller than min → update min = 1
  5. Compare 6 → no change

Final result: max = 9, min = 1

Handling Edge Cases

Case 1: Single Element Array

If the array has only one element, say [5], then that value is both the maximum and minimum by default. There’s nothing else to compare it to.

Case 2: All Elements Are Equal

For example, in [7, 7, 7], every number is the same. So both max and min are 7. No updates will happen during the comparisons.

Case 3: Empty Array

If the array is empty, we can’t find the maximum or minimum. There’s no data to work with. In this case, we should:

  • Return null or undefined
  • Or display a message like: “No elements to compare”

Always remember to check for an empty array at the beginning to avoid runtime errors.

Algorithm Steps❯

  1. Given an array of numbers arr.
  2. If array is empty, return null or -1.
  3. Initialize max_val and min_val with the first element of the array.
  4. Iterate through each element in the array starting from the second element.
  5. If the current element is greater than max_val, update max_val.
  6. If the current element is less than min_val, update min_val.
  7. After the loop, return max_val and min_val.

Code

C
C++
Python
Java
JS
Go
Rust
Kotlin
Swift
TS
#include <stdio.h>

void findMaxMin(int arr[], int n, int *maxVal, int *minVal) {
    *maxVal = arr[0];
    *minVal = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > *maxVal) *maxVal = arr[i];
        if (arr[i] < *minVal) *minVal = arr[i];
    }
}

int main() {
    int arr[] = {-5, -1, -9, 0, 3, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    int maxVal, minVal;
    findMaxMin(arr, n, &maxVal, &minVal);
    printf("Maximum: %d\n", maxVal);
    printf("Minimum: %d\n", minVal);
    return 0;
}

Time Complexity❯

CaseTime ComplexityExplanation
Best CaseO(n)Even in the best case, every element must be checked to ensure no smaller or larger values exist.
Average CaseO(n)Each element is visited once to compare and possibly update the maximum or minimum.
Worst CaseO(n)In the worst case, the loop still traverses the entire array to determine the max and min values.

Space Complexity❯

O(1)

Explanation: Only a fixed number of variables (e.g., max_val, min_val) are used, regardless of input size.

Detailed Step by Step Example❯

Let us take the following array and apply the logic to find the maximum and minimum elements.

{ "array": [6,3,8,2,7,4], "showIndices": true, "highlightIndices": [0] }
{ "array": [0,6,6], "showIndices": false, "highlightIndicesGreen": [1, 2], "emptyCompIndices": [0], "labels": { "1": "max", "2": "min" } }

Initialize max = 6 and min = 6 with the first element of the array.

Check index 1

Compare 3 at index=1 with current max = 6 and min = 6.

3 is smaller than current min. Update min = 3.

{ "array": [6,3,8,2,7,4], "showIndices": true, "highlightIndices": [1], "specialIndices": [], "labels": {"1":"i"} }
{ "array": [0,6,3], "showIndices": false, "highlightIndicesGreen": [1, 2], "emptyCompIndices": [0], "labels": { "1": "max", "2": "min" } }

Check index 2

Compare 8 at index=2 with current max = 6 and min = 3.

8 is greater than current max. Update max = 8.

{ "array": [6,3,8,2,7,4], "showIndices": true, "highlightIndices": [2], "specialIndices": [], "labels": {"2":"i"} }
{ "array": [0,8,3], "showIndices": false, "highlightIndicesGreen": [1, 2], "emptyCompIndices": [0], "labels": { "1": "max", "2": "min" } }

Check index 3

Compare 2 at index=3 with current max = 8 and min = 3.

2 is smaller than current min. Update min = 2.

{ "array": [6,3,8,2,7,4], "showIndices": true, "highlightIndices": [3], "specialIndices": [], "labels": {"3":"i"} }
{ "array": [0,8,2], "showIndices": false, "highlightIndicesGreen": [1, 2], "emptyCompIndices": [0], "labels": { "1": "max", "2": "min" } }

Check index 4

Compare 7 at index=4 with current max = 8 and min = 2.

No update required.

{ "array": [6,3,8,2,7,4], "showIndices": true, "highlightIndices": [4], "specialIndices": [], "labels": {"4":"i"} }
{ "array": [0,8,2], "showIndices": false, "highlightIndicesGreen": [1, 2], "emptyCompIndices": [0], "labels": { "1": "max", "2": "min" } }

Check index 5

Compare 4 at index=5 with current max = 8 and min = 2.

No update required.

{ "array": [6,3,8,2,7,4], "showIndices": true, "highlightIndices": [5], "specialIndices": [], "labels": {"5":"i"} }
{ "array": [0,8,2], "showIndices": false, "highlightIndicesGreen": [1, 2], "emptyCompIndices": [0], "labels": { "1": "max", "2": "min" } }

Final Result:

Maximum = 8, Minimum = 2

{ "array": [6,3,8,2,7,4], "showIndices": true, "labels": { "2": "max", "3": "min" }, "specialIndices": [] }
{ "array": [0,8,2], "showIndices": false, "highlightIndicesGreen": [1, 2], "emptyCompIndices": [0], "labels": { "1": "max", "2": "min" } }

Comments

💬 Please keep your comment relevant and respectful. Avoid spamming, offensive language, or posting promotional/backlink content.
All comments are subject to moderation before being published.

Loading comments...