C++ Algorithm min()

C++ Algorithm min() function can be used in following 3 ways:

It compares the two values passed in its arguments and returns the smaller between them, and if both are equal, then it returns the first one.
It also compares the two values using a binary function, which is defined by the user, and then passed as argument in std::min().
It is also used to find the smallest element in a given list, and it returns the first one if there are more than one are smallest in the list.

Elements are compared using operator< for the first version or using the given binary comparison function comp for the second version.

Syntax

default (1)     template <class T> const T& min (const T& a, const T& b);   //until C++ 11

custom (2)     template <class T, class Compare>
                         const T& min (const T& a, const T& b, Compare comp);      //until C++ 11

default (1)      template <class T> const T& min (const T& a, const T& b);   //until C++ 14

custom (2)       template <class T, class Compare>
                          const T& min (const T& a, const T& b, Compare comp);     //until C++ 14

initializer list (3)      template <class T> T min (initializer_list<T> il);
                                template <class T, class Compare>
                                 T min (initializer_list<T> il, Compare comp);              //until C++ 14

default (1)    template <class T> constexpr const T& min (const T& a, const T& b); 
								     //since C++ 14

custom (2)      template <class T, class Compare>
                          constexp const T& min (const T& a, const T& b, Compare comp);
								    // since C++ 14

initializer list (3)    template <class T> constexpr T min (initializer_list<T> il);
                                 template <class T, class Compare>
                                   constexpr T min (initializer_list<T> il, Compare comp);
								     //since C++ 14

Parameter

a: first value to compare.

b: Second value to compare.

comp: A user defined binary predicate function that accepts two arguments and returns true if the two arguments are in order and false otherwise. It follows the strict weak ordering to order the elements.

il: An initializer_list with the values to compare.

Return value

It returns the smaller of a and b. If the values are equivalent, returns a.

Returns the smallest value in il. If several values are equivalent to the minimum, returns the left most such value.

Complexity

Complexity is linear in one less than the number of elements compared.

Exceptions

This function throws an exception if any comparison throws an exception.

Please note that invalid parameters cause an undefined behavior.

Example 1

Let's see the simple example to demonstrate the use of min():

#include <algorithm>
#include <iostream>
#include <string>

using namespace std;
 
int main()
{
    cout << "smaller of 1 and 9999: " << min(1, 9999) << '\n'
              << "smaller of 'a', and 'b': " << min('a', 'b') << '\n'
              << "shortest of \"foo\", \"bar\", and \"hello\": " <<
                  min( { "foo", "bar", "hello" },
                            [](const string& s1, const string& s2) {
                                 return s1.size() < s2.size();
                             }) << '\n';
                             
    return 0;
}

Output:

smaller of 1 and 9999: 1
smaller of 'a', and 'b': a
shortest of "foo", "bar", and "hello": foo

Example 2

Let's see another simple example to demonstrate the use of min() using default version:

#include <iostream>     // std::cout
#include <algorithm>    // std::min

using namespace std;

int main () {
  cout << "min(1,2)==" << min(1,2) << '\n';
  cout << "min(2,1)==" << min(2,1) << '\n';
  cout << "min('a','z')==" << min('a','z') << '\n';
  cout << "min(3.14,2.72)==" << min(3.14,2.72) << '\n';
  return 0;
}

Output:

min(1,2)==1
min(2,1)==1
min('a','z')==a
min(3.14,2.72)==2.72

Example 3

Let's see another simple example to demonstrate the use of min() using predicate function comp:

#include <iostream> 
#include <algorithm> 
using namespace std; 
  
// Defining the binary function 
bool comp(int a, int b) 
{ 
    return (a < b); 
} 
int main() 
{ 
    int a = 5; 
    int b = 7; 
    cout << min(a, b, comp) << "\n"; 
  
    // Returns the first one if both the numbers 
    // are same 
    cout << min(7, 7, comp); 
  
    return 0; 
}

Output:

5 
7

Example 4

Let's see a simple example to find the minimum element in the list:

#include <iostream> 
#include <algorithm> 
#include <vector> 
using namespace std; 
  
// Defining the binary function 
bool comp(int a, int b) 
{ 
    return (a < b); 
} 
int main() 
{ 
    // Finding the smallest of all the numbers 
cout << "smallest element in the list is: " <<min({ 1, 2, 3, 4, 5, 0, -1, 7 }, comp) << "\n"; 
  
    return 0; 
}

Output: