View source for cpp/algorithm/min element

{{cpp/title|min_element}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header|algorithm}}
{{dcla|num=1|notes={{mark constexpr since c++17}}|
template< class ForwardIt > 
ForwardIt min_element( ForwardIt first, ForwardIt last );
}}
{{dcl|num=2|since=c++17|
template< class ExecutionPolicy, class ForwardIt > 
ForwardIt min_element( ExecutionPolicy&& policy, 
                       ForwardIt first, ForwardIt last );
}}
{{dcla|num=3|notes={{mark constexpr since c++17}}|
template< class ForwardIt, class Compare >
ForwardIt min_element( ForwardIt first, ForwardIt last,
                       Compare comp );
}}
{{dcl|num=4|since=c++17|
template< class ExecutionPolicy, class ForwardIt, class Compare >
ForwardIt min_element( ExecutionPolicy&& policy, 
                       ForwardIt first, ForwardIt last,
                       Compare comp );
}}
{{dcl end}}

Finds the smallest element in the range {{range|first|last}}.

@1@ Elements are compared using {{rev inl|until=c++20|{{c/core|operator<}}}}{{rev inl|since=c++20|{{c|std::less{}<!---->}}}}.

@3@ Elements are compared using the comparison function {{c|comp}}.

@2,4@ Same as {{v|1,3}}, but executed according to {{c|policy}}.
@@ {{cpp/algorithm/parallel overload precondition|plural=yes}}

===Parameters===
{{par begin}}
{{par|first, last|forward iterators defining the range to examine}}
{{par exec pol}}
{{par cmp|comp|p1=ForwardIt}} 
{{par hreq}}
{{par req named|ForwardIt|ForwardIterator}}
{{par end}}

===Return value===
Iterator to the smallest element in the range {{range|first|last}}. If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. Returns {{c|last}} if the range is empty.

===Complexity===
Given {{mathjax-or|\(\scriptsize N\)|N}} as {{c|std::distance(first, last)}}:

@1,2@ Exactly {{mathjax-or|\(\scriptsize \max(N-1,0)\)|max(N-1,0)}} comparisons using {{rev inl|until=c++20|{{c/core|operator<}}}}{{rev inl|since=c++20|{{c|std::less{}<!---->}}}}.

@3,4@ Exactly {{mathjax-or|\(\scriptsize \max(N-1,0)\)|max(N-1,0)}} applications of the comparison function {{c|comp}}.

===Exceptions===
{{cpp/algorithm/parallel exceptions reporting behavior|singular=no}}

===Possible implementation===
{{eq impl
|title1=min_element (1)|ver1=1|1=
template<class ForwardIt>
ForwardIt min_element(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
    
    ForwardIt smallest = first;
    
    while (++first != last)
        if (*first < *smallest)
            smallest = first;
    
    return smallest;
}
|title2=min_element (3)|ver2=3|2=
template<class ForwardIt, class Compare>
ForwardIt min_element(ForwardIt first, ForwardIt last, Compare comp)
{
    if (first == last)
        return last;
    
    ForwardIt smallest = first;
    
    while (++first != last)
        if (comp(*first, *smallest))
            smallest = first;
    
    return smallest;
}
}}

===Example===
{{example
|
|code=
#include <algorithm>
#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> v{3, 1, -4, 1, 5, 9};
    
    std::vector<int>::iterator result = std::min_element(v.begin(), v.end());
    std::cout << "min element has value " << *result << " and index ["
              << std::distance(v.begin(), result) << "]\n";
}
|output=
min element has value -4 and index [2]
}}

===Defect reports===
{{dr list begin}}
{{dr list item|wg=lwg|dr=212|std=C++98|before=the return value was not specified if {{range|first|last}} is empty|after=returns {{c|last}} in this case}}
{{dr list item|wg=lwg|dr=2150|std=C++98|before=the iterator to the first non-greatest element was returned|after=corrected the return value}}
{{dr list end}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/algorithm/dsc max_element}}
{{dsc inc|cpp/algorithm/dsc minmax_element}}
{{dsc inc|cpp/algorithm/dsc min}}
{{dsc inc|cpp/algorithm/ranges/dsc min_element}}
{{dsc end}}

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}