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)
Similar Reads
Difference between the largest and the smallest primes in an array
Given an array of integers where all the elements are less than 10^6. The task is to find the difference between the largest and the smallest prime numbers in the array. Examples: Input : Array = 1, 2, 3, 5 Output : Difference is 3 Explanation : The largest prime number in the array is 5 and the sma
8 min read
Find the smallest and second smallest elements in an array
Given an array arr[] of size N, find the smallest and second smallest element in an array. Examples: Input: arr[] = {12, 13, 1, 10, 34, 1}Output: 1 10Explanation: The smallest element is 1 and second smallest element is 10. Input: arr[] = {111, 13, 25, 9, 34, 1}Output: 1 9Explanation: The smallest e
13 min read
Nearest smaller numbers on left side in an array
Given an array of integers, find the nearest smaller number for every element such that the smaller element is on the left side. Examples: Input: arr = [1, 6, 2]Output: [-1, 1, 1,]Explanation: There is no number at the left of 1. Smaller number than 6 and 2 is 1. Input: arr = [1, 5, 0, 3, 4, 5]Outpu
8 min read
Arrange given numbers to form the smallest number
Given an array arr[] of integer elements, the task is to arrange them in such a way that these numbers form the smallest possible number. For example, if the given array is {5, 6, 2, 9, 21, 1} then the arrangement will be 1212569. Examples: Input: arr[] = {5, 6, 2, 9, 21, 1} Output: 1212569 Input: a
14 min read
JavaScript Program to Find kth Largest/Smallest Element in an Array
JavaScript allows us to find kth largest/smallest element in an array. We are given an array containing some elements, we have to find kth smallest/largest element from the array where k is a number greater than zero and less than equal to the total number of elements present in the array. There are
5 min read
Find Largest and smallest number in an Array containing small as well as large numbers
Given an array arr[] of N small and/or large numbers, the task is to find the largest and smallest number in this array. Examples: Input: N = 4, arr[] = {5677856, 657856745356587687698768, 67564, 45675645356576578564435647647}Output: Smallest: 67564Largest: 45675645356576578564435647647 Input: N = 5
10 min read
kth smallest/largest in a small range unsorted array
Find kth smallest or largest element in an unsorted array, where k<=size of array. It is given that elements of array are in small range. Examples: Input : arr[] = {3, 2, 9, 5, 7, 11, 13} k = 5 Output: 9 Input : arr[] = {16, 8, 9, 21, 43} k = 3 Output: 16 Input : arr[] = {50, 50, 40} k = 2 Output
5 min read
Find Second largest element in an array | Set 2
Given an array arr[] consisting of N integers, the task is to find the second largest element in the given array using N+log2(N) - 2 comparisons. Examples: Input : arr[] = {22, 33, 14, 55, 100, 12}Output : 55 Input : arr[] = {35, 23, 12, 35, 19, 100}Output : 35 Sorting and Two-Traversal Approach: Re
9 min read
Farthest Right Smaller for all in an Array
Given an array arr[] of size n. For every element in the array, your task is to find the index of the farthest element in the array to the right which is smaller than the current element. If no such number exists then return -1. Examples: Input: arr[] = [3, 1, 5, 2, 4] Output: [3, -1, 4, -1, -1] Exp
9 min read
Largest number smaller than or equal to n and digits in non-decreasing order
Given a number n, find the Largest number smaller than or equal to n and digits in non-decreasing order. Examples: Input : n = 200 Output : 199 If the given number is 200, the largest number which is smaller or equal to it having digits in non decreasing order is 199. Input : n = 139 Output : 139Rec
13 min read