How to get largest and smallest number in an Array?
Last Updated :
13 Sep, 2022
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++
#include <bits/stdc++.h>
using namespace std;
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]);
pair< int , int > ans = findMinMax(arr, N);
cout << "Maximum is: " << ans.second << endl;
cout << "Minimum is: " << ans.first;
return 0;
}
|
Java
class GFG {
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;
int [] ans = findMinMax(arr, N);
System.out.print( "Maximum is: " + ans[ 1 ]);
System.out.print( "\n"
+ "Minimum is: " + ans[ 0 ]);
}
}
|
Python3
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)
ans = findMinMax(arr, N)
print (f "Maximum is: {ans[1]}" )
print (f "Minimum is: {ans[0]}" )
|
C#
using System;
public class GFG {
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;
int [] ans = findMinMax(arr, N);
Console.Write( "Maximum is: " + ans[1]);
Console.Write( "\n"
+ "Minimum is: " + ans[0]);
}
}
|
Javascript
<script>
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;
let ans = {};
ans = findMinMax(arr, N);
console.log( "Maximum is: " + ans.second);
console.log( "Minimum is: " + ans.first);
</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++
#include <bits/stdc++.h>
using namespace std;
int findMin( int arr[], int n)
{
return *min_element(arr, arr + n);
}
int findMax( int arr[], int n)
{
return *max_element(arr, arr + n);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << "Maximum is: " << findMax(arr, N) << endl;
cout << "Minimum is: " << findMin(arr, N);
return 0;
}
|
Java
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]);
}
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]);
}
return max;
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 3 , 4 , 5 };
int N = arr.length;
System.out.print( "Maximum is: " + findMax(arr, N));
System.out.print( "\n"
+ "Minimum is: "
+ findMin(arr, N));
}
}
|
Python3
def findMin(arr,n):
return min (arr)
def findMax(arr,n):
return max (arr)
arr = [ 1 , 2 , 3 , 4 , 5 ]
N = len (arr)
print ( "Maximum is: " ,findMax(arr, N))
print ( "Minimum is: " ,findMin(arr, N))
|
C#
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]);
}
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]);
}
return max;
}
public static void Main(String[] args)
{
int [] arr = { 1, 2, 3, 4, 5 };
int N = arr.Length;
Console.Write( "Maximum is: " + findMax(arr, N));
Console.Write( "\n"
+ "Minimum is: "
+ findMin(arr, N));
}
}
|
Javascript
<script>
function findMin(arr,n)
{
let min = arr[0];
for (let i = 1; i < n; i++) {
min = Math.min(
min,
arr[i]);
}
return min;
}
function findMax(arr, n)
{
let max = arr[0];
for (let i = 1; i < n; i++) {
max = Math.max(
max,
arr[i]);
}
return max;
}
let arr = [ 1, 2, 3, 4, 5 ];
let N = arr.length;
console.log( "Maximum is: " + findMax(arr, N));
console.log( "\n"
+ "Minimum is: "
+ findMin(arr, N));
</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++
#include <bits/stdc++.h>
using namespace std;
struct Pair {
int min;
int max;
};
struct Pair getMinAndMax( int arr[], int n)
{
struct Pair minmax;
int i;
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];
}
i = 2;
}
else {
minmax.min = arr[0];
minmax.max = arr[0];
i = 1;
}
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];
}
i += 2;
}
return minmax;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
Pair minmax = getMinAndMax(arr, N);
cout << "Maximum is: " << minmax.max << endl;
cout << "Minimum is: " << minmax.min;
return 0;
}
|
Java
import java.util.*;
class GFG{
static class Pair {
int min;
int max;
Pair() {
}
};
static Pair getMinAndMax( int arr[], int n)
{
Pair minmax = new Pair();
int i;
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 ];
}
i = 2 ;
}
else {
minmax.min = arr[ 0 ];
minmax.max = arr[ 0 ];
i = 1 ;
}
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];
}
i += 2 ;
}
return minmax;
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 };
int N = arr.length;
Pair minmax = getMinAndMax(arr, N);
System.out.print( "Maximum is: " + minmax.max + "\n" );
System.out.print( "Minimum is: " + minmax.min);
}
}
|
Python3
minmax = [ 0 , 0 ]
def getMinAndMax(arr,n):
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 ]
i = 2 ;
else :
minmax[ 0 ] = arr[ 0 ]
minmax[ 1 ] = arr[ 0 ]
i = 1
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]
i + = 2
arr = [ 1 , 2 , 3 , 4 , 5 ]
N = len (arr)
getMinAndMax(arr, N);
print ( "Maximum is: " , minmax[ 1 ] )
print ( "Minimum is: " , minmax[ 0 ] )
|
C#
using System;
public class GFG{
class Pair {
public int min;
public int max;
public Pair() {
}
};
static Pair getMinAndMax( int []arr, int n)
{
Pair minmax = new Pair();
int i;
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];
}
i = 2;
}
else {
minmax.min = arr[0];
minmax.max = arr[0];
i = 1;
}
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];
}
i += 2;
}
return minmax;
}
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4, 5 };
int N = arr.Length;
Pair minmax = getMinAndMax(arr, N);
Console.Write( "Maximum is: " + minmax.max + "\n" );
Console.Write( "Minimum is: " + minmax.min);
}
}
|
Javascript
<script>
let minmax = [0,0]
function getMinAndMax(arr,n)
{
let i;
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];
}
i = 2;
}
else {
minmax[0] = arr[0];
minmax[1] = arr[0];
i = 1;
}
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];
}
i += 2;
}
}
let arr = [ 1, 2, 3, 4, 5 ];
let N = arr.length;
getMinAndMax(arr, N);
console.log( "Maximum is: " + minmax[1] );
console.log( "Minimum is: " + minmax[0] );
</script>
|
Output
Maximum is: 5
Minimum is: 1
Time Complexity: O(N)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...