C++11

// <algorithm> 
// 默认(1)    
template <class ForwardIterator>
    pair<ForwardIterator,ForwardIterator>
    minmax_element (
        ForwardIterator first,
        ForwardIterator last);
// 自定义(2)    
template <class ForwardIterator, class Compare>
    pair<ForwardIterator,ForwardIterator>
    minmax_element (
        ForwardIterator first,
        ForwardIterator last,
        ​Compare comp);

返回给定范围中值最大及最小的元素。

该函数等价于:

template<class _FwdIt,
class _Pr> inline
    pair<_FwdIt, _FwdIt>
    _Minmax_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
{	// find smallest and largest elements, using _Pred
    pair<_FwdIt, _FwdIt> _Found(_First, _First);

    if (_First != _Last)
        for (; ++_First != _Last;)
        {	// process one or two elements
        _FwdIt _Next = _First;
        if (++_Next == _Last)
        {	// process last element
            if (_DEBUG_LT_PRED(_Pred, *_First, *_Found.first))
                _Found.first = _First;
            else if (!_DEBUG_LT_PRED(_Pred, *_First, *_Found.second))
                _Found.second = _First;
        }
        else
        {	// process next two elements
            if (_DEBUG_LT_PRED(_Pred, *_Next, *_First))
            {	// test _Next for new smallest
                if (_DEBUG_LT_PRED(_Pred, *_Next, *_Found.first))
                    _Found.first = _Next;
                if (!_DEBUG_LT_PRED(_Pred, *_First, *_Found.second))
                    _Found.second = _First;
            }
            else
            {	// test _First for new smallest
                if (_DEBUG_LT_PRED(_Pred, *_First, *_Found.first))
                    _Found.first = _First;
                if (!_DEBUG_LT_PRED(_Pred, *_Next, *_Found.second))
                    _Found.second = _Next;
            }
            _First = _Next;
        }
        }
    return (_Found);
}
  • firstlast

    分别指向序列中初始及末尾位置的正向迭代器(Forward Iterators)。这个范围即 [first,last) ,包括 first 到 last 间的所有元素,包括 first 指向的元素,但不包括 last 指向的元素。

    comp

    二元谓词(Binary)函数,以范围中的两个元素为参数,然后返回一个可转换成 bool 类型的值。

    其返回值表明按所指定的严格弱序排序(Strict weak ordering)时,第一个参数所传进来的元素是否在第二个参数所传进来的元素前面。

    该函数不能修改其参数。

    可以是函数指针(Function pointer)类型或函数对象(Function object)类型。

  • 返回一个 std::pair,其中 first 成员为指向最小值的迭代器,second 成员为指向最大值的迭代器。

  • 参照 std::sort 以获得与自定义函数谓词、函数对象谓词、对象数组、lambda 表达式 C++11、初始化列表 std::initializer_list C++11 等相关的例子。

    例 1

    #include <iostream>
    #include <algorithm>
    #include <iterator>
    #include <vector>
    
    #define CLASSFOO_VECTOR(type, name, ...) \
    static const type name##_a[] = __VA_ARGS__; \
    std::vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a))
    
    namespace ClassFoo{
        void MinMaxElement_1() {
            CLASSFOO_VECTOR(int, foo, { 8, 23, -5, 7, 29, 0, 7, 7, -7, 1, -1 });
            std::pair<
                std::vector<int>::iterator, 
                std::vector<int>::iterator> p = std::minmax_element(foo.begin(), foo.end());
            std::cout << *p.first << "  " << *p.second << std::endl;
        }
    }
    int main()
    {
        ClassFoo::MinMaxElement_1();
        return 0;
    }

    -7  29

  • 复杂度

    O(3/2(N - 1))N 等值于 std::distance(first,last)

    数据争用相关

    范围 [first,last) 中的所有元素都被访问过。

    异常安全性相关

    如果元素比较(Compare)或操作某个迭代器抛异常,该函数才会抛异常。

    注意 无效参数将导致未定义行为(Undefined behavior)