c++ 最大和最小算法

Penguin

身体和灵魂总有一个在路上

主要函数

min():两个值中较小的。.
max():两个值中较大的。
min_element():序列中的最小元素。
max_element():序列中的最大元素。
minax():序列中的最大最小元素，比较两个元素的大小
minmax_element():序列中的最大最小元素

min函数模板（C++98）的行为等效于：

template <class T> const T& min (const T& a, const T& b) {
  return !(b<a)?a:b;     // or: return !comp(b,a)?a:b; for version (2)
}

min函数返回两个值中较小一个;如果这两个值相等，则返回第一个值。第一个版本使用<来确定顺序，而第二个版本使用comp比较对象。

template<class T>
T min (initializer_list<T> t);
template<class T, class Compare>
T min(initializer_list<T> t, Compare comp) ;

这个版本的min()函数是C++11新增的，它返回初始化列表t中最小的值。如果有多个相等的值且最小，则返回第一个。第一个版本使用<来确定顺序，而第二个版本使用comp 比较对象。

min_element函数模板的行为等效于：

template <class ForwardIterator>
  ForwardIterator min_element ( ForwardIterator first, ForwardIterator last )
  if (first==last) return last;
  ForwardIterator smallest = first;
  while (++first!=last)
    if (*first<*smallest)    // or: if (comp(*first,*smallest)) for version (2)
      smallest=first;
  return smallest;
}

min_element()函数返回这样一个迭代器，该迭代器指向[first, last)区间中第一个最小的元素。第一个版本使用<来确定顺序，而第二个版本使用comp比较对象。

max函数模板（C++98）的行为等效于：

template <class T> const T& max (const T& a, const T& b) {
  return (a<b)?b:a;     // or: return comp(a,b)?b:a; for version (2)
}

max()函数返回这两个值中较大的一个;如果这两个值相等，则返回第一个值。第一个版本使用<来确定顺序，而第二个版本使用comp 比较对象。

template<class T> 
T max(initializer_list<T> t);
template<class T, class Compare>
T max(initializer_list<T> t, Compare comp) ;

这个版本的max()函数是C++11新增的，它返回初始化列表t中最大的值。如果有多个相等的值且最大，则返回第一个。第一个版本使用<来确定顺序，而第二个版本使用comp 比较对象。

max_element函数模板的行为等效于：

template <class ForwardIterator>
  ForwardIterator max_element ( ForwardIterator first, ForwardIterator last )
  if (first==last) return last;
  ForwardIterator largest = first;
  while (++first!=last)
    if (*largest<*first)    // or: if (comp(*largest,*first)) for version (2)
      largest=first;
  return largest;
}

max_element()函数返回这样一个迭代器，该迭代器指向[first,last]区间中第一个最大的元素。第一个版本使用<来确定顺序，而第二个版本使用comp 比较对象。

minmax函数模板(其中之一)的行为等效于：

template <class T> pair <const T&,const T&> minmax (const T& a, const T& b) {
  return (b<a) ? std::make_pair(b,a) : std::make_pair(a,b);
}

如果b小于a，minmax()函数返回pair(b, a)，否则返回pair(a, b)。第一个版本使用<来确定顺序，而第二个版本使用comp比较对象。

template<class T> 
pair<T, T> minmax (initializer_list<T> t);
template<class T, class Compare>
pair<T, T> minmax(initializer_list<T> t), Compare comp) ;

这个版本的minmax()函数返回初始化列表t中最小元素和最大元素的拷贝。如果有多个最小的元素，则返回其中的第一个;如果有多个最大的元素，则返回其中的最后一个。第一个版本使用<来确定顺序，而第二个版本使用comp比较对象。

minmax_element函数模板的原型为:

template<class ForwardIterator>
pair<ForwardIterator, ForwardIterator> minmax_element (ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
pair<ForwardIterator, ForwardIterator> minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);

函数minmax_element()返回一个pair对象，其中包含两个迭代器，分别指向区间[first, last)中最小和最大的元素。第一个版本使用<来确定顺序，而第二个版本使用comp比较对象。

例子:

#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
int main(){
    int a = min(10, 20);
    int b = max(10, 20);
    int c = min({1, 4, 2, 10, 6, 5, 9, 7, 8, 3});
    int d = max({1, 4, 2, 10, 6, 5, 9, 7, 8, 3});
    pair<int, int> p = minmax({1, 4, 2, 10, 6, 5, 9, 7, 8, 3});
    cout<< "min(10, 20) : " << a << endl;
    cout<< "man(10, 20) : " << b << endl;
    cout<< "min in a: " << c << endl;
    cout<< "man in a: " << d << endl;
    cout<< "minmax in a: " << p.first << "," << p.second << endl;
    int array[] = {1, 10, 5, 7, 9};
    cout<< " 原始array[]: ";
    copy(array, array + 5, ostream_iterator<int>(cout, " "));
    cout<< endl;
    int *it_min = min_element(array, array + 5);
    int *it_max = max_element(array, array + 5);