What will be the number of comparisons needed to find simultaneously both the minimum and maximum from n elements?

For any $N$-sized array, I would like to prove that the minimum number of comparisons to find both the max and min element simultaneously is

\begin{align} \frac{3N}{2} - 2 && \text{N: even} \\ \frac{3(N-1)}{2} && \text{N: odd} \end{align}

It's clear to me that the above number of comparisons can guarantee that the minimum and maximum can be found. For the even case, all you need to do is consider $N/2$ distinct pairs (by distinct pairs, I just mean that no 2 pairs have any of the same elements). For each pair $(a,b)$, you find $x = \max(a,b)$ and $y = \min(a,b)$. Then you compare $x$ with the running max and y with the running y. So for each pair, excluding the first pair, we require 3 comparisons. For the first pair, we don't need to compare $x$ with the running max and y with the running y because the running max and min can be set to $x$ and $y$, respectively, since it wasn't initialized already. Hence why we have $-2$ in the answer.

For an odd $N$, the idea is the same, except the last element cannot be paired. So we have $(N-1)/2$ pairs, giving us $\frac{3(N-1)}{2} - 2$ comparisons, and the last element adds 2 comparisons, giving us $\frac{3(N-1)}{2}$.

Okay, but I don't know how to show that you cannot do any better than the above. How can I prove that the above bounds are lower bounds?

Improve Article

Save Article

Like Article

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

First of all, how do we return multiple values from a function? We can do it either using structures or pointers. 
We have created a structure named pair (which contains min and max) to return multiple values. 

struct pair {

    int min;

    int max;

};

struct pair {

    int min;

    int max;

};

static class pair {

    int min;

    int max;

};

class pair:

    def __init__(self):

        self.min = None

        self.max = None

public static class pair {

    public int min;

    public int max;

};

<script>

class pair

{

  constructor(){

    this.min = null;

    this.max = null;

  }

};

</script>

What will be the number of comparisons needed to find simultaneously both the minimum and maximum from n elements?

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:

#include<iostream>

using namespace std;

struct Pair

{

    int min;

    int max;

};

Pair getMinMax(int arr[], int n)

{

    struct Pair minmax;    

    int i;

    if (n == 1)

    {

        minmax.max = arr[0];

        minmax.min = arr[0];    

        return minmax;

    }

    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;

}

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;

}

#include<stdio.h>

struct pair

{

  int min;

  int max;

}; 

struct pair getMinMax(int arr[], int n)

{

  struct pair minmax;    

  int i;

  if (n == 1)

  {

     minmax.max = arr[0];

     minmax.min = arr[0];    

     return minmax;

  }   

  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;

}

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();

public class GFG {

    static class Pair {

        int min;

        int max;

    }

    static Pair getMinMax(int arr[], int n) {

        Pair minmax = new  Pair();

        int i;

        if (n == 1) {

            minmax.max = arr[0];

            minmax.min = arr[0];

            return minmax;

        }

        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;

    }

    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);

    }

}

class pair:

    def __init__(self):

        self.min = 0

        self.max = 0

def getMinMax(arr: list, n: int) -> pair:

    minmax = pair()

    if n == 1:

        minmax.max = arr[0]

        minmax.min = arr[0]

        return minmax

    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

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)

using System;

class GFG

{

    class Pair

    {

        public int min;

        public int max;

    }

    static Pair getMinMax(int []arr, int n)

    {

        Pair minmax = new Pair();

        int i;

        if (n == 1)

        {

            minmax.max = arr[0];

            minmax.min = arr[0];

            return minmax;

        }

        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;

    }

    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);

    }

}

<script>

    function getMinMax(arr, n)

    {

        minmax = new  Array();

        var i;

        var min;

        var max;

        if (n == 1) {

            minmax.max = arr[0];

            minmax.min = arr[0];

            return minmax;

        }

        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;

    }

        var arr = [1000, 11, 445, 1, 330, 3000];

        var arr_size = 6;

        minmax = getMinMax(arr, arr_size);

        document.write("\nMinimum element is " ,minmax.min +"<br>");

        document.write("\nMaximum element is " , minmax.max);

</script>

Output: 

Minimum element is 1 Maximum element is 3000

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

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 method:

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.

Pair MaxMin(array, array_size)    if array_size = 1        return element as both max and min    else if arry_size = 2        one comparison to determine max and min         return that pair    else    /* array_size  > 2 */        recur for max and min of left half        recur for max and min of right half        one comparison determines true max of the two candidates        one comparison determines true min of the two candidates

        return the pair of max and min

Below is the implementation of the above approach:

#include <iostream>

using namespace std;

struct Pair {

    int min;

    int max;

};

struct Pair getMinMax(int arr[], int low, int high)

{

    struct Pair minmax, mml, mmr;

    int mid;

    if (low == high) {

        minmax.max = arr[low];

        minmax.min = arr[low];

        return minmax;

    }

    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;

    }

    mid = (low + high) / 2;

    mml = getMinMax(arr, low, mid);

    mmr = getMinMax(arr, mid + 1, high);

    if (mml.min < mmr.min)

        minmax.min = mml.min;

    else

        minmax.min = mmr.min;

    if (mml.max > mmr.max)

        minmax.max = mml.max;

    else

        minmax.max = mmr.max;

    return minmax;

}

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;

}

#include <stdio.h>

struct pair {

    int min;

    int max;

};

struct pair getMinMax(int arr[], int low, int high)

{

    struct pair minmax, mml, mmr;

    int mid;

    if (low == high) {

        minmax.max = arr[low];

        minmax.min = arr[low];

        return minmax;

    }

    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;

    }

    mid = (low + high) / 2;

    mml = getMinMax(arr, low, mid);

    mmr = getMinMax(arr, mid + 1, high);

    if (mml.min < mmr.min)

        minmax.min = mml.min;

    else

        minmax.min = mmr.min;

    if (mml.max > mmr.max)

        minmax.max = mml.max;

    else

        minmax.max = mmr.max;

    return minmax;

}

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();

}

public class GFG {

    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 (low == high) {

            minmax.max = arr[low];

            minmax.min = arr[low];

            return minmax;

        }

        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;

        }

        mid = (low + high) / 2;

        mml = getMinMax(arr, low, mid);

        mmr = getMinMax(arr, mid + 1, high);

        if (mml.min < mmr.min) {

            minmax.min = mml.min;

        }

        else {

            minmax.min = mmr.min;

        }

        if (mml.max > mmr.max) {

            minmax.max = mml.max;

        }

        else {

            minmax.max = mmr.max;

        }

        return minmax;

    }

    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);

    }

}

def getMinMax(low, high, arr):

    arr_max = arr[low]

    arr_min = arr[low]

    if low == high:

        arr_max = arr[low]

        arr_min = arr[low]

        return (arr_max, arr_min)

    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:

        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))

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)

using System;

public class GFG {

    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 (low == high) {

            minmax.max = arr[low];

            minmax.min = arr[low];

            return minmax;

        }

        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;

        }

        mid = (low + high) / 2;

        mml = getMinMax(arr, low, mid);

        mmr = getMinMax(arr, mid + 1, high);

        if (mml.min < mmr.min) {

            minmax.min = mml.min;

        }

        else {

            minmax.min = mmr.min;

        }

        if (mml.max > mmr.max) {

            minmax.max = mml.max;

        }

        else {

            minmax.max = mmr.max;

        }

        return minmax;

    }

    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);

    }

}

<script>

     class Pair {

         constructor(){

        this.min = -1;

        this.max = 10000000;

         }

    }

     function getMinMax(arr , low , high) {

        var minmax = new Pair();

        var mml = new Pair();

        var mmr = new Pair();

        var mid;

        if (low == high) {

            minmax.max = arr[low];

            minmax.min = arr[low];

            return minmax;

        }

        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;

        }

        mid = parseInt((low + high) / 2);

        mml = getMinMax(arr, low, mid);

        mmr = getMinMax(arr, mid + 1, high);

        if (mml.min < mmr.min) {

            minmax.min = mml.min;

        } else {

            minmax.min = mmr.min;

        }

        if (mml.max > mmr.max) {

            minmax.max = mml.max;

        } else {

            minmax.max = mmr.max;

        }

        return minmax;

    }

        var arr = [ 1000, 11, 445, 1, 330, 3000 ];

        var arr_size = 6;

        var minmax = getMinMax(arr, 0, arr_size - 1);

        document.write("\nMinimum element is ", minmax.min);

        document.write("<br/>Maximum element is ", minmax.max);

</script>

OutputMinimum 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.

Total number of comparisons: let the number of comparisons be T(n). T(n) can be written as follows: 
Algorithmic Paradigm: Divide and Conquer 

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:

If 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:

#include<iostream>

using namespace std;

struct Pair

{

    int min;

    int max;

};

struct Pair getMinMax(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[] = { 1000, 11, 445,

                1, 330, 3000 };

    int arr_size = 6;

    Pair minmax = getMinMax(arr, arr_size);

    cout << "nMinimum element is "

        << minmax.min << endl;

    cout << "nMaximum element is "

        << minmax.max;

    return 0;

}

#include<stdio.h>

struct pair

{

  int min;

  int max;

}; 

struct pair getMinMax(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[] = {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();

}

public class GFG {

    static class Pair {

        int min;

        int max;

    }

    static Pair getMinMax(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[] = {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);

    }

}

def getMinMax(arr):

    n = len(arr)

    if(n % 2 == 0):

        mx = max(arr[0], arr[1])

        mn = min(arr[0], arr[1])

        i = 2

    else:

        mx = mn = arr[0]

        i = 1

    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])

        i += 2

    return (mx, mn)

if __name__ =='__main__':

    arr = [1000, 11, 445, 1, 330, 3000]

    mx, mn = getMinMax(arr)

    print("Minimum element is", mn)

    print("Maximum element is", mx)

using System;

class GFG

{

    public class Pair

    {

        public int min;

        public int max;

    }

    static Pair getMinMax(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 = {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);

    }

}

<script>

function getMinMax(arr){

    let n = arr.length

    let mx,mn,i

    if(n % 2 == 0){

        mx = Math.max(arr[0], arr[1])

        mn = Math.min(arr[0], arr[1])

        i = 2

    }

    else{

        mx = mn = arr[0]

        i = 1

    }

    while(i < n - 1){

        if(arr[i] < arr[i + 1]){

            mx = Math.max(mx, arr[i + 1])

            mn = Math.min(mn, arr[i])

        }

        else{

            mx = Math.max(mx, arr[i])

            mn = Math.min(mn, arr[i + 1])

        }

        i += 2

    }

    return [mx, mn]

}

let arr = [1000, 11, 445, 1, 330, 3000]

let mx = getMinMax(arr)[0]

let mn = getMinMax(arr)[1]

document.write("Minimum element is", mn,"</br>")

document.write("Maximum element is", mx,"</br>")

</script>

Output: 

Minimum element is 1 Maximum element is 3000

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

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 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

Second and third approaches make the equal number of comparisons when n is a power of 2. In general, method 3 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.