How to get largest and smallest number in an Array?

Given an array arr[] of length N, The task is to find the maximum and the minimum number in the array.

Examples:

Input: arr[] = {1, 2, 3, 4, 5}
Output: Maximum is: 5
Minimum is: 1
Explanation: The maximum of the array is 5 
and the minimum of the array is 1.

Input: arr[] = {5, 3, 7, 4, 2}
Output: Maximum is: 7
Minimum is: 2

Approach 1(Greedy): The problem can be solved using the greedy approach:

The solution is to compare each array element for minimum and maximum elements by considering a single item at a time.

Follow the steps to solve the problem:

• Create a variable mini/maxi and initialize it with the value at index zero of the array.
• Iterate over the array and compare if the current element is greater than the maxi or less than the mini.
• Update the mini/maxi element with the current element so that the minimum/maximum element is stored in the mini/maxi variable.
• Return the mini/maxi variable.

Below is the implementation of the above idea:

C++

// C++ code to implement the idea

#include <bits/stdc++.h>
using namespace std;

// Function to find the minimum
// and maxximum of the array
pair<int, int> findMinMax(int arr[], int n)
{
    int mini = arr[0];
    int maxi = arr[0];

    for (int i = 0; i < n; i++) {
        if (arr[i] < mini) {
            mini = arr[i];
        }
        else if (arr[i] > maxi) {
            maxi = arr[i];
        }
    }
    return { mini, maxi };
}

int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);

    // Function Call
    pair<int, int> ans = findMinMax(arr, N);
    cout << "Maximum is: " << ans.second << endl;
    cout << "Minimum is: " << ans.first;
    return 0;
}

Java

// Java Code to implement the above idea

class GFG {

    // Function to find the minimum and maxximum of the
    // array
    static int[] findMinMax(int[] arr, int n)
    {
        int mini = arr[0];
        int maxi = arr[0];

        for (int i = 0; i < n; i++) {
            if (arr[i] < mini) {
                mini = arr[i];
            }
            else if (arr[i] > maxi) {
                maxi = arr[i];
            }
        }
        int[] ans = new int[2];
        ans[0] = mini;
        ans[1] = maxi;
        return ans;
    }

    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
          int N = arr.length;

        // Function call
        int[] ans = findMinMax(arr, N);
        System.out.print("Maximum is: " + ans[1]);
        System.out.print("\n"
                         + "Minimum is: " + ans[0]);
    }
}

// This code is contributed by lokesh(lokeshmvs21).

Python3

# python3 code to implement the idea

# Function to find the minimum
# and maxximum of the array


def findMinMax(arr, n):

    mini = arr[0]
    maxi = arr[0]

    for i in range(0, n):
        if (arr[i] < mini):
            mini = arr[i]

        elif (arr[i] > maxi):
            maxi = arr[i]

    return [mini, maxi]


if __name__ == "__main__":

    arr = [1, 2, 3, 4, 5]
    N = len(arr)

    # Function Call
    ans = findMinMax(arr, N)
    print(f"Maximum is: {ans[1]}")
    print(f"Minimum is: {ans[0]}")

    # This code is contributed by rakeshsahni

C#

// C# Code to implement the above idea
using System;

public class GFG {

  // Function to find the minimum and maxximum of the
  // array
  static int[] findMinMax(int[] arr, int n)
  {
    int mini = arr[0];
    int maxi = arr[0];

    for (int i = 0; i < n; i++) {
      if (arr[i] < mini) {
        mini = arr[i];
      }
      else if (arr[i] > maxi) {
        maxi = arr[i];
      }
    }
    int[] ans = new int[2];
    ans[0] = mini;
    ans[1] = maxi;
    return ans;
  }

  public static void Main(String[] args)
  {
    int[] arr = { 1, 2, 3, 4, 5 };
    int N = arr.Length;

    // Function call
    int[] ans = findMinMax(arr, N);
    Console.Write("Maximum is: " + ans[1]);
    Console.Write("\n"
                  + "Minimum is: " + ans[0]);
  }
}

// This code is contributed by shikhasingrajput

Javascript

<script>
// Javascript code to implement the idea

// Function to find the minimum
// and maxximum of the array
function findMinMax(arr,n)
{
    let mini = arr[0];
    let maxi = arr[0];

    for (let i = 0; i < n; i++) {
        if (arr[i] < mini) {
            mini = arr[i];
        }
        else if (arr[i] > maxi) {
            maxi = arr[i];
        }
    }
    let ans = {
        "first":mini,
        "second":maxi
    }
    return ans;
}

    let arr = [ 1, 2, 3, 4, 5 ];
    let N = arr.length;

    // Function Call
    let ans = {};
    ans = findMinMax(arr, N);
    console.log("Maximum is: " + ans.second);
    console.log("Minimum is: " + ans.first);

// This code is contributed by akashish__
</script>

Output

Maximum is: 5
Minimum is: 1

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 2(Library Function): The problem can be solved using the library functions provided in different programming languages.

We can use min_element() and max_element() to find the minimum and maximum elements of the array in C++.

Below is the implementation of the above idea:

C++

// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the minimum value
int findMin(int arr[], int n)
{
    return *min_element(arr, arr + n);
}

// Function to find the maximum value
int findMax(int arr[], int n)
{
    return *max_element(arr, arr + n);
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);

    // Function call
    cout << "Maximum is: " << findMax(arr, N) << endl;
    cout << "Minimum is: " << findMin(arr, N);
    return 0;
}

Java

// Java Code to use the inbuilt Math functions

class GFG {

    static int findMin(int[] arr, int n)
    {
        int min = arr[0];
        for (int i = 1; i < n; i++) {
            min = Math.min(
                min,
                arr[i]); // Function to get minimum element
        }
        return min;
    }

    static int findMax(int[] arr, int n)
    {
        int max = arr[0];
        for (int i = 1; i < n; i++) {
            max = Math.max(
                max,
                arr[i]); // Function to get maximum element
        }
        return max;
    }

    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        int N = arr.length;

        // Function call
        System.out.print("Maximum is: " + findMax(arr, N));
        System.out.print("\n"
                         + "Minimum is: "
                         + findMin(arr, N));
    }
}

// This code is contributed by lokesh (lokeshmvs21).

Python3

# Python3 code to implement the approach

# Function to find the minimum value
def findMin(arr,n):
  return min(arr)

# Function to find the maximum value
def findMax(arr,n):
  return max(arr)

# Driver code
arr = [ 1, 2, 3, 4, 5 ]
N = len(arr)

# Function call
print("Maximum is: " ,findMax(arr, N))
print("Minimum is: " ,findMin(arr, N))

# This code is contributed by akashish__

C#

// C# Code to use the inbuilt Math functions

using System;

public class GFG {

    static int findMin(int[] arr, int n)
    {
        int min = arr[0];
        for (int i = 1; i < n; i++) {
            min = Math.Min(
                min,
                arr[i]); // Function to get minimum element
        }
        return min;
    }

    static int findMax(int[] arr, int n)
    {
        int max = arr[0];
        for (int i = 1; i < n; i++) {
            max = Math.Max(
                max,
                arr[i]); // Function to get maximum element
        }
        return max;
    }

    public static void Main(String[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        int N = arr.Length;

        // Function call
        Console.Write("Maximum is: " + findMax(arr, N));
        Console.Write("\n"
                         + "Minimum is: "
                         + findMin(arr, N));
    }
}


// This code contributed by shikhasingrajput

Javascript

<script>
// Function to find the minimum value
function findMin(arr,n)
{
    let min = arr[0];
        for (let i = 1; i < n; i++) {
            min = Math.min(
                min,
                arr[i]); // Function to get minimum element
        }
        return min;
}

// Function to find the maximum value
function findMax(arr, n)
{
let max = arr[0];
        for (let i = 1; i < n; i++) {
            max = Math.max(
                max,
                arr[i]); // Function to get maximum element
        }
        return max;
}

let arr = [ 1, 2, 3, 4, 5 ];
        let N = arr.length;

        // Function call
        console.log("Maximum is: " + findMax(arr, N));
        console.log("\n"
                         + "Minimum is: "
                         + findMin(arr, N));

// This code is contributed by akashish__

</script>

Output

Maximum is: 5
Minimum is: 1

Time Complexity: O(N)
Auxiliary Space: O(1)

Approach 3(Minimum comparisons): To solve the problem with minimum number of comparisons, follow the below steps:

• If N is odd then initialize mini and maxi as the first element. 
• If N is even then initialize mini and maxi as minimum and maximum of the first two elements respectively. 
• For the rest of the elements, pick them in pairs and compare
  • Maximum and minimum with maxi and mini respectively. 

The total number of comparisons will be:

If N is odd: 3*(N – 1)/2  
If N is even: 1 Initial comparison for initializing min and max, and 3(N – 2)/2 comparisons for rest of the elements 
=  1 + 3*(N – 2) / 2 = 3N / 2 – 2

Below is the implementation of the above idea:

C++

// C++ code to implement the idea

#include <bits/stdc++.h>
using namespace std;

// Structure is used to return
// two values from minMax()
struct Pair {
    int min;
    int max;
};

// Function to get the minimum and the maximum
struct Pair getMinAndMax(int arr[], int n)
{
    struct Pair minmax;
    int i;

    // If array has even number of elements
    // then initialize the first two elements
    // as minimum and maximum
    if (n % 2 == 0) {
        if (arr[0] > arr[1]) {
            minmax.max = arr[0];
            minmax.min = arr[1];
        }
        else {
            minmax.min = arr[0];
            minmax.max = arr[1];
        }

        // Set the starting index for loop
        i = 2;
    }

    // If array has odd number of elements
    // then initialize the first element as
    // minimum and maximum
    else {
        minmax.min = arr[0];
        minmax.max = arr[0];

        // Set the starting index for loop
        i = 1;
    }

    // In the while loop, pick elements in
    // pair and compare the pair with max
    // and min so far
    while (i < n - 1) {
        if (arr[i] > arr[i + 1]) {
            if (arr[i] > minmax.max)
                minmax.max = arr[i];

            if (arr[i + 1] < minmax.min)
                minmax.min = arr[i + 1];
        }
        else {
            if (arr[i + 1] > minmax.max)
                minmax.max = arr[i + 1];

            if (arr[i] < minmax.min)
                minmax.min = arr[i];
        }

        // Increment the index by 2 as
        // two elements are processed in loop
        i += 2;
    }
    return minmax;
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
    // Function call
    Pair minmax = getMinAndMax(arr, N);

    cout << "Maximum is: " << minmax.max << endl;
    cout << "Minimum is: " << minmax.min;
    return 0;
}

Java

// Java code to implement the idea


import java.util.*;

class GFG{

// Structure is used to return
// two values from minMax()
static class Pair {
    int min;
    int max;
    Pair() {
    }

};

// Function to get the minimum and the maximum
static Pair getMinAndMax(int arr[], int n)
{
    Pair minmax = new Pair();
    int i;

    // If array has even number of elements
    // then initialize the first two elements
    // as minimum and maximum
    if (n % 2 == 0) {
        if (arr[0] > arr[1]) {
            minmax.max = arr[0];
            minmax.min = arr[1];
        }
        else {
            minmax.min = arr[0];
            minmax.max = arr[1];
        }

        // Set the starting index for loop
        i = 2;
    }

    // If array has odd number of elements
    // then initialize the first element as
    // minimum and maximum
    else {
        minmax.min = arr[0];
        minmax.max = arr[0];

        // Set the starting index for loop
        i = 1;
    }

    // In the while loop, pick elements in
    // pair and compare the pair with max
    // and min so far
    while (i < n - 1) {
        if (arr[i] > arr[i + 1]) {
            if (arr[i] > minmax.max)
                minmax.max = arr[i];

            if (arr[i + 1] < minmax.min)
                minmax.min = arr[i + 1];
        }
        else {
            if (arr[i + 1] > minmax.max)
                minmax.max = arr[i + 1];

            if (arr[i] < minmax.min)
                minmax.min = arr[i];
        }

        // Increment the index by 2 as
        // two elements are processed in loop
        i += 2;
    }
    return minmax;
}

// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = arr.length;
    // Function call
    Pair minmax = getMinAndMax(arr, N);

    System.out.print("Maximum is: " +  minmax.max +"\n");
    System.out.print("Minimum is: " +  minmax.min);
}
}

// This code contributed by shikhasingrajput

Python3

# Python3 code to implement the idea

# array is used to return
# two values from minMax()
# min = arr[0], max = arr[1]
minmax = [0,0]

# Function to get the minimum and the maximum
def getMinAndMax(arr,n):

    # If array has even number of elements
    # then initialize the first two elements
    # as minimum and maximum
  if (n % 2 == 0):
    if (arr[0] > arr[1]):
      minmax[0] = arr[0]
      minmax[1] = arr[1]
    else:
      minmax[0] = arr[0]
      minmax[1] = arr[1]

      # Set the starting index for loop
    i = 2;

    # If array has odd number of elements
    # then initialize the first element as
    # minimum and maximum
  else:
    minmax[0] = arr[0]
    minmax[1] = arr[0]

     # Set the starting index for loop
    i = 1

    # In the while loop, pick elements in
    # pair and compare the pair with max
    # and min so far
    while (i < n - 1):
        if (arr[i] > arr[i + 1]):
            if (arr[i] > minmax[1]):
                minmax[1] = arr[i]

            if (arr[i + 1] < minmax[0]):
                minmax[0] = arr[i + 1]
        else:
            if (arr[i + 1] > minmax[1]):
                minmax[1] = arr[i + 1]

            if (arr[i] < minmax[0]):
                minmax[0] = arr[i]

        # Increment the index by 2 as
        # two elements are processed in loop
        i += 2

# Driver code
arr = [ 1, 2, 3, 4, 5 ]
N = len(arr)

# Function call
getMinAndMax(arr, N);

print( "Maximum is: " , minmax[1] )
print( "Minimum is: " , minmax[0] )

# This code is contributed by akashish__

C#

// C# code to implement the idea


using System;

public class GFG{

// Structure is used to return
// two values from minMax()
class Pair {
    public int min;
    public int max;
    public Pair() {
    }

};

// Function to get the minimum and the maximum
static Pair getMinAndMax(int []arr, int n)
{
    Pair minmax = new Pair();
    int i;

    // If array has even number of elements
    // then initialize the first two elements
    // as minimum and maximum
    if (n % 2 == 0) {
        if (arr[0] > arr[1]) {
            minmax.max = arr[0];
            minmax.min = arr[1];
        }
        else {
            minmax.min = arr[0];
            minmax.max = arr[1];
        }

        // Set the starting index for loop
        i = 2;
    }

    // If array has odd number of elements
    // then initialize the first element as
    // minimum and maximum
    else {
        minmax.min = arr[0];
        minmax.max = arr[0];

        // Set the starting index for loop
        i = 1;
    }

    // In the while loop, pick elements in
    // pair and compare the pair with max
    // and min so far
    while (i < n - 1) {
        if (arr[i] > arr[i + 1]) {
            if (arr[i] > minmax.max)
                minmax.max = arr[i];

            if (arr[i + 1] < minmax.min)
                minmax.min = arr[i + 1];
        }
        else {
            if (arr[i + 1] > minmax.max)
                minmax.max = arr[i + 1];

            if (arr[i] < minmax.min)
                minmax.min = arr[i];
        }

        // Increment the index by 2 as
        // two elements are processed in loop
        i += 2;
    }
    return minmax;
}

// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 3, 4, 5 };
    int N = arr.Length;
    // Function call
    Pair minmax = getMinAndMax(arr, N);

    Console.Write("Maximum is: " +  minmax.max +"\n");
    Console.Write("Minimum is: " +  minmax.min);
}
}


// This code contributed by shikhasingrajput

Javascript

<script>

// Javascript code to implement the idea


// array is used to return
// two values from minMax()
// min = arr[0], max = arr[1]
let minmax = [0,0]

// Function to get the minimum and the maximum
function getMinAndMax(arr,n)
{
    let i;

    // If array has even number of elements
    // then initialize the first two elements
    // as minimum and maximum
    if (n % 2 == 0) {
        if (arr[0] > arr[1]) {
            minmax[0] = arr[0];
            minmax[1] = arr[1];
        }
        else {
            minmax[0] = arr[0];
            minmax[1] = arr[1];
        }

        // Set the starting index for loop
        i = 2;
    }

    // If array has odd number of elements
    // then initialize the first element as
    // minimum and maximum
    else {
        minmax[0] = arr[0];
        minmax[1] = arr[0];

        // Set the starting index for loop
        i = 1;
    }

    // In the while loop, pick elements in
    // pair and compare the pair with max
    // and min so far
    while (i < n - 1) {
        if (arr[i] > arr[i + 1]) {
            if (arr[i] > minmax[1])
                minmax[1] = arr[i];

            if (arr[i + 1] < minmax[0])
                minmax[0] = arr[i + 1];
        }
        else {
            if (arr[i + 1] > minmax[1])
                minmax[1] = arr[i + 1];

            if (arr[i] < minmax[0])
                minmax[0] = arr[i];
        }

        // Increment the index by 2 as
        // two elements are processed in loop
        i += 2;
    }
}

// Driver code
let arr = [ 1, 2, 3, 4, 5 ];
let N = arr.length;
// Function call
getMinAndMax(arr, N);

console.log( "Maximum is: " + minmax[1] );
console.log( "Minimum is: " + minmax[0] );

// contributed by akashish__

</script>

Output

Maximum is: 5
Minimum is: 1

Time Complexity: O(N)
Auxiliary Space: O(1)