# Maximum and minimum of an array using minimum number of comparisons

Given an array of size N. The task is to find the maximum and the minimum element of the array using the minimum number of comparisons.

Examples:

Input: arr[] = {3, 5, 4, 1, 9}
Output: Minimum element is: 1
Maximum element is: 9

Input: arr[] = {22, 14, 8, 17, 35, 3}
Output:  Minimum element is: 3
Maximum element is: 35

Recommended Practice

## Maximum and minimum of an array using Sorting:

One approach to find the maximum and minimum element in an array is to first sort the array in ascending order. Once the array is sorted, the first element of the array will be the minimum element and the last element of the array will be the maximum element.

Step-by-step approach:

• Initialize an array.
• Sort the array in ascending order.
• The first element of the array will be the minimum element.
• The last element of the array will be the maximum element.
• Print the minimum and maximum element.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;`   `struct` `Pair {` `    ``int` `min;` `    ``int` `max;` `};`   `Pair getMinMax(``int` `arr[], ``int` `n)` `{` `    ``Pair minmax;`   `    ``sort(arr, arr + n);`   `    ``minmax.min = arr[0];` `    ``minmax.max = arr[n - 1];`   `    ``return` `minmax;` `}`   `int` `main()` `{` `    ``int` `arr[] = { 1000, 11, 445, 1, 330, 3000 };` `    ``int` `arr_size = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``Pair minmax = getMinMax(arr, arr_size);`   `    ``cout << ``"Minimum element is "` `<< minmax.min << endl;` `    ``cout << ``"Maximum element is "` `<< minmax.max << endl;`   `    ``return` `0;` `}`   `// This code is contributed by Tapesh(tapeshdua420)`

## Java

 `import` `java.io.*;` `import` `java.util.*;`   `class` `Pair {` `    ``public` `int` `min;` `    ``public` `int` `max;` `}`   `class` `Main {` `    ``static` `Pair getMinMax(``int` `arr[], ``int` `n) {` `        ``Pair minmax = ``new` `Pair();` `        ``Arrays.sort(arr);` `        ``minmax.min = arr[``0``];` `        ``minmax.max = arr[n - ``1``];` `        ``return` `minmax;` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int` `arr[] = { ``1000``, ``11``, ``445``, ``1``, ``330``, ``3000` `};` `        ``int` `arr_size = arr.length;` `        ``Pair minmax = getMinMax(arr, arr_size);` `        ``System.out.println(``"Minimum element is "` `+ minmax.min);` `        ``System.out.println(``"Maximum element is "` `+ minmax.max);` `    ``}` `}`

## Python

 `def` `getMinMax(arr):` `    ``arr.sort()` `    ``minmax ``=` `{``"min"``: arr[``0``], ``"max"``: arr[``-``1``]}` `    ``return` `minmax`   `arr ``=` `[``1000``, ``11``, ``445``, ``1``, ``330``, ``3000``]` `minmax ``=` `getMinMax(arr)`   `print``(``"Minimum element is"``, minmax[``"min"``])` `print``(``"Maximum element is"``, minmax[``"max"``])`

## C#

 `using` `System;`   `public` `struct` `Pair` `{` `    ``public` `int` `min;` `    ``public` `int` `max;` `}`   `class` `Program {` `    ``// Function to find the minimum and maximum elements in` `    ``// an array` `    ``static` `Pair GetMinMax(``int``[] arr, ``int` `n)` `    ``{` `        ``Pair minmax = ``new` `Pair();`   `        ``// Sort the array in ascending order` `        ``Array.Sort(arr);`   `        ``// The first element after sorting is the minimum` `        ``minmax.min = arr[0];`   `        ``// The last element after sorting is the maximum` `        ``minmax.max = arr[n - 1];`   `        ``return` `minmax;` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``int``[] arr = { 1000, 11, 445, 1, 330, 3000 };` `        ``int` `arrSize = arr.Length;`   `        ``// Find the minimum and maximum elements in the` `        ``// array` `        ``Pair minmax = GetMinMax(arr, arrSize);`   `        ``// Print the minimum and maximum elements` `        ``Console.WriteLine(``"Minimum element is "` `                          ``+ minmax.min);` `        ``Console.WriteLine(``"Maximum element is "` `                          ``+ minmax.max);` `    ``}` `}`

## Javascript

 `// Function to find the minimum and maximum elements in an array` `function` `getMinMax(arr) {` `    ``// Create an object to store the minimum and maximum values` `    ``const minmax = {};`   `    ``// Sort the array in ascending order` `    ``arr.sort((a, b) => a - b);`   `    ``// Store the minimum element as the first element of the sorted array` `    ``minmax.min = arr[0];` `    ``// Store the maximum element as the last element of the sorted array` `    ``minmax.max = arr[arr.length - 1];`   `    ``// Return the object containing the minimum and maximum values` `    ``return` `minmax;` `}`   `// Main function` `function` `main() {` `    ``// Given array` `    ``const arr = [1000, 11, 445, 1, 330, 3000];` `    `  `    ``// Call the getMinMax function to find the minimum and maximum values` `    ``const minmax = getMinMax(arr);`   `    ``// Print the minimum element` `    ``console.log(``"Minimum element is "` `+ minmax.min);` `    ``// Print the maximum element` `    ``console.log(``"Maximum element is "` `+ minmax.max);` `}`   `// Call the main function to start the program` `main();`

Output

```Minimum element is 1
Maximum element is 3000

```

Time complexity: O(n log n), where n is the number of elements in the array, as we are using a sorting algorithm.
Auxilary Space: is O(1), as we are not using any extra space.

### Number of Comparisons:

The number of comparisons made to find the minimum and maximum elements is equal to the number of comparisons made during the sorting process. For any comparison-based sorting algorithm, the minimum number of comparisons required to sort an array of n elements is O(n log n). Hence, the number of comparisons made in this approach is also O(n log n).

## Maximum and minimum of an array using Linear search:

Initialize values of min and max as minimum and maximum of the first two elements respectively. Starting from 3rd, compare each element with max and min, and change max and min accordingly (i.e., if the element is smaller than min then change min, else if the element is greater than max then change max, else ignore the element)

Below is the implementation of the above approach:

## C++

 `// C++ program of above implementation ` `#include` `using` `namespace` `std;`   `// Pair struct is used to return ` `// two values from getMinMax()` `struct` `Pair ` `{` `    ``int` `min;` `    ``int` `max;` `}; `   `Pair getMinMax(``int` `arr[], ``int` `n)` `{` `    ``struct` `Pair minmax;     ` `    ``int` `i;` `    `  `    ``// If there is only one element ` `    ``// then return it as min and max both` `    ``if` `(n == 1)` `    ``{` `        ``minmax.max = arr[0];` `        ``minmax.min = arr[0];     ` `        ``return` `minmax;` `    ``} ` `    `  `    ``// If there are more than one elements,` `    ``// then initialize min and max` `    ``if` `(arr[0] > arr[1]) ` `    ``{` `        ``minmax.max = arr[0];` `        ``minmax.min = arr[1];` `    ``} ` `    ``else` `    ``{` `        ``minmax.max = arr[1];` `        ``minmax.min = arr[0];` `    ``} ` `    `  `    ``for``(i = 2; i < n; i++)` `    ``{` `        ``if` `(arr[i] > minmax.max)     ` `            ``minmax.max = arr[i];` `            `  `        ``else` `if` `(arr[i] < minmax.min)     ` `            ``minmax.min = arr[i];` `    ``}` `    ``return` `minmax;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1000, 11, 445, ` `                  ``1, 330, 3000 };` `    ``int` `arr_size = 6;` `    `  `    ``struct` `Pair minmax = getMinMax(arr, arr_size);` `    `  `    ``cout << ``"Minimum element is "` `         ``<< minmax.min << endl;` `    ``cout << ``"Maximum element is "` `         ``<< minmax.max;` `         `  `    ``return` `0;` `} `   `// This code is contributed by nik_3112`

## C

 `/* structure is used to return two values from minMax() */` `#include` `struct` `pair ` `{` `  ``int` `min;` `  ``int` `max;` `};  `   `struct` `pair getMinMax(``int` `arr[], ``int` `n)` `{` `  ``struct` `pair minmax;     ` `  ``int` `i;` `  `  `  ``/*If there is only one element then return it as min and max both*/` `  ``if` `(n == 1)` `  ``{` `     ``minmax.max = arr[0];` `     ``minmax.min = arr[0];     ` `     ``return` `minmax;` `  ``}    `   `  ``/* If there are more than one elements, then initialize min ` `      ``and max*/` `  ``if` `(arr[0] > arr[1])  ` `  ``{` `      ``minmax.max = arr[0];` `      ``minmax.min = arr[1];` `  ``}  ` `  ``else` `  ``{` `      ``minmax.max = arr[1];` `      ``minmax.min = arr[0];` `  ``}    `   `  ``for` `(i = 2; i  minmax.max)      ` `      ``minmax.max = arr[i];` `  `  `    ``else` `if` `(arr[i] <  minmax.min)      ` `      ``minmax.min = arr[i];` `  ``}` `  `  `  ``return` `minmax;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `  ``int` `arr[] = {1000, 11, 445, 1, 330, 3000};` `  ``int` `arr_size = 6;` `  ``struct` `pair minmax = getMinMax (arr, arr_size);` `  ``printf``(``"nMinimum element is %d"``, minmax.min);` `  ``printf``(``"nMaximum element is %d"``, minmax.max);` `  ``getchar``();` `}  `

## Java

 `import` `java.io.*;` `import` `java.util.*;`   `// Java program of above implementation` `public` `class` `GFG {` `/* Class Pair is used to return two values from getMinMax() */` `    ``static` `class` `Pair {`   `        ``int` `min;` `        ``int` `max;` `    ``}`   `    ``static` `Pair getMinMax(``int` `arr[], ``int` `n) {` `        ``Pair minmax = ``new`  `Pair();` `        ``int` `i;`   `        ``/*If there is only one element then return it as min and max both*/` `        ``if` `(n == ``1``) {` `            ``minmax.max = arr[``0``];` `            ``minmax.min = arr[``0``];` `            ``return` `minmax;` `        ``}`   `        ``/* If there are more than one elements, then initialize min ` `    ``and max*/` `        ``if` `(arr[``0``] > arr[``1``]) {` `            ``minmax.max = arr[``0``];` `            ``minmax.min = arr[``1``];` `        ``} ``else` `{` `            ``minmax.max = arr[``1``];` `            ``minmax.min = arr[``0``];` `        ``}`   `        ``for` `(i = ``2``; i < n; i++) {` `            ``if` `(arr[i] > minmax.max) {` `                ``minmax.max = arr[i];` `            ``} ``else` `if` `(arr[i] < minmax.min) {` `                ``minmax.min = arr[i];` `            ``}` `        ``}`   `        ``return` `minmax;` `    ``}`   `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String args[]) {` `        ``int` `arr[] = {``1000``, ``11``, ``445``, ``1``, ``330``, ``3000``};` `        ``int` `arr_size = ``6``;` `        ``Pair minmax = getMinMax(arr, arr_size);` `        ``System.out.printf(``"\nMinimum element is %d"``, minmax.min);` `        ``System.out.printf(``"\nMaximum element is %d"``, minmax.max);`   `    ``}`   `}`

## Python3

 `# Python program of above implementation`   `# structure is used to return two values from minMax()`   `class` `pair:` `    ``def` `__init__(``self``):` `        ``self``.``min` `=` `0` `        ``self``.``max` `=` `0`   `def` `getMinMax(arr: ``list``, n: ``int``) ``-``> pair:` `    ``minmax ``=` `pair()`   `    ``# If there is only one element then return it as min and max both` `    ``if` `n ``=``=` `1``:` `        ``minmax.``max` `=` `arr[``0``]` `        ``minmax.``min` `=` `arr[``0``]` `        ``return` `minmax`   `    ``# If there are more than one elements, then initialize min` `    ``# and max` `    ``if` `arr[``0``] > arr[``1``]:` `        ``minmax.``max` `=` `arr[``0``]` `        ``minmax.``min` `=` `arr[``1``]` `    ``else``:` `        ``minmax.``max` `=` `arr[``1``]` `        ``minmax.``min` `=` `arr[``0``]`   `    ``for` `i ``in` `range``(``2``, n):` `        ``if` `arr[i] > minmax.``max``:` `            ``minmax.``max` `=` `arr[i]` `        ``elif` `arr[i] < minmax.``min``:` `            ``minmax.``min` `=` `arr[i]`   `    ``return` `minmax`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1000``, ``11``, ``445``, ``1``, ``330``, ``3000``]` `    ``arr_size ``=` `6` `    ``minmax ``=` `getMinMax(arr, arr_size)` `    ``print``(``"Minimum element is"``, minmax.``min``)` `    ``print``(``"Maximum element is"``, minmax.``max``)`   `# This code is contributed by` `# sanjeev2552`

## C#

 `// C# program of above implementation` `using` `System;`   `class` `GFG ` `{` `    ``/* Class Pair is used to return ` `    ``two values from getMinMax() */` `    ``class` `Pair ` `    ``{` `        ``public` `int` `min;` `        ``public` `int` `max;` `    ``}`   `    ``static` `Pair getMinMax(``int` `[]arr, ``int` `n)` `    ``{` `        ``Pair minmax = ``new` `Pair();` `        ``int` `i;`   `        ``/* If there is only one element ` `        ``then return it as min and max both*/` `        ``if` `(n == 1)` `        ``{` `            ``minmax.max = arr[0];` `            ``minmax.min = arr[0];` `            ``return` `minmax;` `        ``}`   `        ``/* If there are more than one elements,` `        ``then initialize min and max*/` `        ``if` `(arr[0] > arr[1])` `        ``{` `            ``minmax.max = arr[0];` `            ``minmax.min = arr[1];` `        ``} ` `        ``else` `        ``{` `            ``minmax.max = arr[1];` `            ``minmax.min = arr[0];` `        ``}`   `        ``for` `(i = 2; i < n; i++)` `        ``{` `            ``if` `(arr[i] > minmax.max) ` `            ``{` `                ``minmax.max = arr[i];` `            ``} ` `            ``else` `if` `(arr[i] < minmax.min)` `            ``{` `                ``minmax.min = arr[i];` `            ``}` `        ``}` `        ``return` `minmax;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String []args) ` `    ``{` `        ``int` `[]arr = {1000, 11, 445, 1, 330, 3000};` `        ``int` `arr_size = 6;` `        ``Pair minmax = getMinMax(arr, arr_size);` `        ``Console.Write(``"Minimum element is {0}"``,` `                                   ``minmax.min);` `        ``Console.Write(``"\nMaximum element is {0}"``, ` `                                     ``minmax.max);` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

```Minimum element is 1
Maximum element is 3000

```

Time Complexity: O(n)
Auxiliary Space: O(1) as no extra space was needed.

### Number of Comparisons:

In this method, the total number of comparisons is 1 + 2*(n-2) in the worst case and 1 + (n-2) in the best case.
In the above implementation, the worst case occurs when elements are sorted in descending order and the best case occurs when elements are sorted in ascending order.

## Maximum and minimum of an array using the Tournament Mmethod:

The idea is to divide the array into two parts and compare the maximums and minimums of the two parts to get the maximum and the minimum of the whole array.

Below is the implementation of the above approach:

## C++

 `// C++ program of above implementation` `#include ` `using` `namespace` `std;`   `// structure is used to return` `// two values from minMax()` `struct` `Pair {` `    ``int` `min;` `    ``int` `max;` `};`   `struct` `Pair getMinMax(``int` `arr[], ``int` `low, ``int` `high)` `{` `    ``struct` `Pair minmax, mml, mmr;` `    ``int` `mid;`   `    ``// If there is only one element` `    ``if` `(low == high) {` `        ``minmax.max = arr[low];` `        ``minmax.min = arr[low];` `        ``return` `minmax;` `    ``}`   `    ``// If there are two elements` `    ``if` `(high == low + 1) {` `        ``if` `(arr[low] > arr[high]) {` `            ``minmax.max = arr[low];` `            ``minmax.min = arr[high];` `        ``}` `        ``else` `{` `            ``minmax.max = arr[high];` `            ``minmax.min = arr[low];` `        ``}` `        ``return` `minmax;` `    ``}`   `    ``// If there are more than 2 elements` `    ``mid = (low + high) / 2;` `    ``mml = getMinMax(arr, low, mid);` `    ``mmr = getMinMax(arr, mid + 1, high);`   `    ``// Compare minimums of two parts` `    ``if` `(mml.min < mmr.min)` `        ``minmax.min = mml.min;` `    ``else` `        ``minmax.min = mmr.min;`   `    ``// Compare maximums of two parts` `    ``if` `(mml.max > mmr.max)` `        ``minmax.max = mml.max;` `    ``else` `        ``minmax.max = mmr.max;`   `    ``return` `minmax;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1000, 11, 445, 1, 330, 3000 };` `    ``int` `arr_size = 6;`   `    ``struct` `Pair minmax = getMinMax(arr, 0, arr_size - 1);`   `    ``cout << ``"Minimum element is "` `<< minmax.min << endl;` `    ``cout << ``"Maximum element is "` `<< minmax.max;`   `    ``return` `0;` `}`   `// This code is contributed by nik_3112`

## C

 `/* structure is used to return two values from minMax() */` `#include ` `struct` `pair {` `    ``int` `min;` `    ``int` `max;` `};`   `struct` `pair getMinMax(``int` `arr[], ``int` `low, ``int` `high)` `{` `    ``struct` `pair minmax, mml, mmr;` `    ``int` `mid;`   `    ``// If there is only one element` `    ``if` `(low == high) {` `        ``minmax.max = arr[low];` `        ``minmax.min = arr[low];` `        ``return` `minmax;` `    ``}`   `    ``/* If there are two elements */` `    ``if` `(high == low + 1) {` `        ``if` `(arr[low] > arr[high]) {` `            ``minmax.max = arr[low];` `            ``minmax.min = arr[high];` `        ``}` `        ``else` `{` `            ``minmax.max = arr[high];` `            ``minmax.min = arr[low];` `        ``}` `        ``return` `minmax;` `    ``}`   `    ``/* If there are more than 2 elements */` `    ``mid = (low + high) / 2;` `    ``mml = getMinMax(arr, low, mid);` `    ``mmr = getMinMax(arr, mid + 1, high);`   `    ``/* compare minimums of two parts*/` `    ``if` `(mml.min < mmr.min)` `        ``minmax.min = mml.min;` `    ``else` `        ``minmax.min = mmr.min;`   `    ``/* compare maximums of two parts*/` `    ``if` `(mml.max > mmr.max)` `        ``minmax.max = mml.max;` `    ``else` `        ``minmax.max = mmr.max;`   `    ``return` `minmax;` `}`   `/* Driver program to test above function */` `int` `main()` `{` `    ``int` `arr[] = { 1000, 11, 445, 1, 330, 3000 };` `    ``int` `arr_size = 6;` `    ``struct` `pair minmax = getMinMax(arr, 0, arr_size - 1);` `    ``printf``(``"nMinimum element is %d"``, minmax.min);` `    ``printf``(``"nMaximum element is %d"``, minmax.max);` `    ``getchar``();` `}`

## Java

 `import` `java.io.*;` `import` `java.util.*;` `// Java program of above implementation` `public` `class` `GFG {` `    ``/* Class Pair is used to return two values from` `     ``* getMinMax() */` `    ``static` `class` `Pair {`   `        ``int` `min;` `        ``int` `max;` `    ``}`   `    ``static` `Pair getMinMax(``int` `arr[], ``int` `low, ``int` `high)` `    ``{` `        ``Pair minmax = ``new` `Pair();` `        ``Pair mml = ``new` `Pair();` `        ``Pair mmr = ``new` `Pair();` `        ``int` `mid;`   `        ``// If there is only one element` `        ``if` `(low == high) {` `            ``minmax.max = arr[low];` `            ``minmax.min = arr[low];` `            ``return` `minmax;` `        ``}`   `        ``/* If there are two elements */` `        ``if` `(high == low + ``1``) {` `            ``if` `(arr[low] > arr[high]) {` `                ``minmax.max = arr[low];` `                ``minmax.min = arr[high];` `            ``}` `            ``else` `{` `                ``minmax.max = arr[high];` `                ``minmax.min = arr[low];` `            ``}` `            ``return` `minmax;` `        ``}`   `        ``/* If there are more than 2 elements */` `        ``mid = (low + high) / ``2``;` `        ``mml = getMinMax(arr, low, mid);` `        ``mmr = getMinMax(arr, mid + ``1``, high);`   `        ``/* compare minimums of two parts*/` `        ``if` `(mml.min < mmr.min) {` `            ``minmax.min = mml.min;` `        ``}` `        ``else` `{` `            ``minmax.min = mmr.min;` `        ``}`   `        ``/* compare maximums of two parts*/` `        ``if` `(mml.max > mmr.max) {` `            ``minmax.max = mml.max;` `        ``}` `        ``else` `{` `            ``minmax.max = mmr.max;` `        ``}`   `        ``return` `minmax;` `    ``}`   `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `arr[] = { ``1000``, ``11``, ``445``, ``1``, ``330``, ``3000` `};` `        ``int` `arr_size = ``6``;` `        ``Pair minmax = getMinMax(arr, ``0``, arr_size - ``1``);` `        ``System.out.printf(``"\nMinimum element is %d"``,` `                          ``minmax.min);` `        ``System.out.printf(``"\nMaximum element is %d"``,` `                          ``minmax.max);` `    ``}` `}`

## Python3

 `# Python program of above implementation` `def` `getMinMax(low, high, arr):` `    ``arr_max ``=` `arr[low]` `    ``arr_min ``=` `arr[low]`   `    ``# If there is only one element` `    ``if` `low ``=``=` `high:` `        ``arr_max ``=` `arr[low]` `        ``arr_min ``=` `arr[low]` `        ``return` `(arr_max, arr_min)`   `    ``# If there is only two element` `    ``elif` `high ``=``=` `low ``+` `1``:` `        ``if` `arr[low] > arr[high]:` `            ``arr_max ``=` `arr[low]` `            ``arr_min ``=` `arr[high]` `        ``else``:` `            ``arr_max ``=` `arr[high]` `            ``arr_min ``=` `arr[low]` `        ``return` `(arr_max, arr_min)` `    ``else``:`   `        ``# If there are more than 2 elements` `        ``mid ``=` `int``((low ``+` `high) ``/` `2``)` `        ``arr_max1, arr_min1 ``=` `getMinMax(low, mid, arr)` `        ``arr_max2, arr_min2 ``=` `getMinMax(mid ``+` `1``, high, arr)`   `    ``return` `(``max``(arr_max1, arr_max2), ``min``(arr_min1, arr_min2))`     `# Driver code` `arr ``=` `[``1000``, ``11``, ``445``, ``1``, ``330``, ``3000``]` `high ``=` `len``(arr) ``-` `1` `low ``=` `0` `arr_max, arr_min ``=` `getMinMax(low, high, arr)` `print``(``'Minimum element is '``, arr_min)` `print``(``'nMaximum element is '``, arr_max)`   `# This code is contributed by DeepakChhitarka`

## C#

 `// C# implementation of the approach` `using` `System;`   `public` `class` `GFG {` `    ``/* Class Pair is used to return two values from` `     ``* getMinMax() */` `    ``public` `class` `Pair {`   `        ``public` `int` `min;` `        ``public` `int` `max;` `    ``}`   `    ``static` `Pair getMinMax(``int``[] arr, ``int` `low, ``int` `high)` `    ``{` `        ``Pair minmax = ``new` `Pair();` `        ``Pair mml = ``new` `Pair();` `        ``Pair mmr = ``new` `Pair();` `        ``int` `mid;`   `        ``// If there is only one element` `        ``if` `(low == high) {` `            ``minmax.max = arr[low];` `            ``minmax.min = arr[low];` `            ``return` `minmax;` `        ``}`   `        ``/* If there are two elements */` `        ``if` `(high == low + 1) {` `            ``if` `(arr[low] > arr[high]) {` `                ``minmax.max = arr[low];` `                ``minmax.min = arr[high];` `            ``}` `            ``else` `{` `                ``minmax.max = arr[high];` `                ``minmax.min = arr[low];` `            ``}` `            ``return` `minmax;` `        ``}`   `        ``/* If there are more than 2 elements */` `        ``mid = (low + high) / 2;` `        ``mml = getMinMax(arr, low, mid);` `        ``mmr = getMinMax(arr, mid + 1, high);`   `        ``/* compare minimums of two parts*/` `        ``if` `(mml.min < mmr.min) {` `            ``minmax.min = mml.min;` `        ``}` `        ``else` `{` `            ``minmax.min = mmr.min;` `        ``}`   `        ``/* compare maximums of two parts*/` `        ``if` `(mml.max > mmr.max) {` `            ``minmax.max = mml.max;` `        ``}` `        ``else` `{` `            ``minmax.max = mmr.max;` `        ``}`   `        ``return` `minmax;` `    ``}`   `    ``/* Driver program to test above function */` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] arr = { 1000, 11, 445, 1, 330, 3000 };` `        ``int` `arr_size = 6;` `        ``Pair minmax = getMinMax(arr, 0, arr_size - 1);` `        ``Console.Write(``"\nMinimum element is {0}"``,` `                      ``minmax.min);` `        ``Console.Write(``"\nMaximum element is {0}"``,` `                      ``minmax.max);` `    ``}` `}`   `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output

```Minimum element is 1
Maximum element is 3000

```

Time Complexity: O(n)
Auxiliary Space: O(log n) as the stack space will be filled for the maximum height of the tree formed during recursive calls same as a binary tree.

### Number of Comparisons:

Let the number of comparisons be T(n). T(n) can be written as follows:

T(n) = T(floor(n/2)) + T(ceil(n/2)) + 2
T(2) = 1
T(1) = 0

If n is a power of 2, then we can write T(n) as:

T(n) = 2T(n/2) + 2

After solving the above recursion, we get

T(n) = 3n/2 -2

Thus, the approach does 3n/2 -2 comparisons if n is a power of 2. And it does more than 3n/2 -2 comparisons if n is not a power of 2.

## Maximum and minimum of an array by comparing in pairs:

The idea is that when n is odd then initialize min and max as the first element. If n is even then initialize min and max as minimum and maximum of the first two elements respectively. For the rest of the elements, pick them in pairs and compare their maximum and minimum with max and min respectively.

Below is the implementation of the above approach:

## C++

 `// C++ program of above implementation ` `#include ` `using` `namespace` `std; `   `// Structure is used to return ` `// two values from minMax() ` `struct` `Pair ` `{ ` `    ``int` `min; ` `    ``int` `max; ` `}; `   `struct` `Pair getMinMax(``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[] = { 1000, 11, 445, ` `                ``1, 330, 3000 }; ` `    ``int` `arr_size = 6; ` `    `  `    ``Pair minmax = getMinMax(arr, arr_size); ` `    `  `    ``cout << ``"Minimum element is "` `        ``<< minmax.min << endl; ` `    ``cout << ``"Maximum element is "` `        ``<< minmax.max; ` `        `  `    ``return` `0; ` `} `   `// This code is contributed by nik_3112 `

## C

 `#include`   `/* structure is used to return two values from minMax() */` `struct` `pair ` `{` `  ``int` `min;` `  ``int` `max;` `};  `   `struct` `pair getMinMax(``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];` `    ``}` `    ``i = 2;  ``/* set the starting index for loop */` `  ``}  `   `   ``/* 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];` `    ``i = 1;  ``/* set the starting index for loop */` `  ``}` `  `  `  ``/* 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];        ` `    ``}        ` `    ``i += 2; ``/* Increment the index by 2 as two ` `               ``elements are processed in loop */` `  ``}            `   `  ``return` `minmax;` `}    `   `/* Driver program to test above function */` `int` `main()` `{` `  ``int` `arr[] = {1000, 11, 445, 1, 330, 3000};` `  ``int` `arr_size = 6;` `  ``struct` `pair minmax = getMinMax (arr, arr_size);` `  ``printf``(``"Minimum element is %d"``, minmax.min);` `  ``printf``(``"\nMaximum element is %d"``, minmax.max);` `  ``getchar``();` `}`

## Java

 `import` `java.io.*;` `import` `java.util.*;` `// Java program of above implementation` `public` `class` `GFG {`   `/* Class Pair is used to return two values from getMinMax() */` `    ``static` `class` `Pair {`   `        ``int` `min;` `        ``int` `max;` `    ``}`   `    ``static` `Pair getMinMax(``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``];` `            ``}` `            ``i = ``2``;` `            ``/* set the starting index for loop */` `        ``} ``/* 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``];` `            ``i = ``1``;` `            ``/* set the starting index for loop */` `        ``}`   `        ``/* 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];` `                ``}` `            ``}` `            ``i += ``2``;` `            ``/* Increment the index by 2 as two  ` `               ``elements are processed in loop */` `        ``}`   `        ``return` `minmax;` `    ``}`   `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String args[]) {` `        ``int` `arr[] = {``1000``, ``11``, ``445``, ``1``, ``330``, ``3000``};` `        ``int` `arr_size = ``6``;` `        ``Pair minmax = getMinMax(arr, arr_size);` `        ``System.out.printf(``"Minimum element is %d"``, minmax.min);` `        ``System.out.printf(``"\nMaximum element is %d"``, minmax.max);`   `    ``}` `}`

## Python3

 `# Python3 program of above implementation ` `def` `getMinMax(arr):` `    `  `    ``n ``=` `len``(arr)` `    `  `    ``# 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``]:` `            ``mn ``=` `arr[``0``]` `            ``mx ``=` `arr[``1``]` `        ``else``:` `            ``mn ``=` `arr[``1``]` `            ``mx ``=` `arr[``0``]` `        `  `        ``# 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``:` `        ``mx ``=` `mn ``=` `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``]:` `            ``mx ``=` `max``(mx, arr[i ``+` `1``])` `            ``mn ``=` `min``(mn, arr[i])` `        ``else``:` `            ``mx ``=` `max``(mx, arr[i])` `            ``mn ``=` `min``(mn, arr[i ``+` `1``])` `            `  `        ``# Increment the index by 2 as two ` `        ``# elements are processed in loop ` `        ``i ``+``=` `2` `    `  `    ``return` `(mx, mn)` `    `  `# Driver Code` `if` `__name__ ``=``=``'__main__'``:` `    `  `    ``arr ``=` `[``1000``, ``11``, ``445``, ``1``, ``330``, ``3000``]` `    ``mx, mn ``=` `getMinMax(arr)` `    ``print``(``"Minimum element is"``, mn)` `    ``print``(``"Maximum element is"``, mx)` `    `  `# This code is contributed by Kaustav`

## C#

 `// C# program of above implementation` `using` `System;` `    `  `class` `GFG ` `{`   `    ``/* Class Pair is used to return ` `       ``two values from getMinMax() */` `    ``public` `class` `Pair ` `    ``{` `        ``public` `int` `min;` `        ``public` `int` `max;` `    ``}`   `    ``static` `Pair getMinMax(``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];` `            ``}` `            ``i = 2;` `        ``}` `        `  `        ``/* set the starting index for loop */` `        ``/* 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];` `            ``i = 1;` `            ``/* set the starting index for loop */` `        ``}`   `        ``/* 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];` `                ``}` `            ``}` `            ``i += 2;` `            `  `            ``/* Increment the index by 2 as two ` `            ``elements are processed in loop */` `        ``}` `        ``return` `minmax;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String []args) ` `    ``{` `        ``int` `[]arr = {1000, 11, 445, 1, 330, 3000};` `        ``int` `arr_size = 6;` `        ``Pair minmax = getMinMax(arr, arr_size);` `        ``Console.Write(``"Minimum element is {0}"``,` `                                   ``minmax.min);` `        ``Console.Write(``"\nMaximum element is {0}"``, ` `                                     ``minmax.max);` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

```Minimum element is 1
Maximum element is 3000

```

Time Complexity: O(n)
Auxiliary Space: O(1) as no extra space was needed.

### Number of Comparisons:

The total number of comparisons: Different for even and odd n, see below:

If n is odd: 3*(n-1)/2

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

The third and fourth approaches make an equal number of comparisons when n is a power of 2.
In general, method 4 seems to be the best.
Please write comments if you find any bug in the above programs/algorithms or a better way to solve the same problem.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next