Skip to content
Related Articles

Related Articles

How to get largest and smallest number in an Array?

Improve Article
Save Article
  • Last Updated : 13 Sep, 2022
Improve Article
Save Article

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)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!