C++最小/最大（min；max；minmax；min_element；max_element；minmax_element）

最新推荐文章于 2024-06-23 21:45:46 发布
最新推荐文章于 2024-06-23 21:45:46 发布
阅读量7.8k 收藏 10
点赞数 2
分类专栏： C++ 文章标签： C++ min max minmax element
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_34884208/article/details/87893517
版权

一、min

头文件algorithm

【C++ 98】

default (1)	
template <class T> const T& min (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  const T& min (const T& a, const T& b, Compare comp);

【C++ 11】

default (1)	
template <class T> const T& min (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  const T& min (const T& a, const T& b, Compare comp);
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);

【C++ 14】

default (1)	
template <class T> constexpr const T& min (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  constexpr const T& min (const T& a, const T& b, Compare comp);
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);

返回最小的

返回a和b中的最小值。 如果两者都是等价的，则返回a。

初始化列表（3）的版本返回列表中所有元素中最小的元素。 如果这些不止一个，则返回第一个。

该函数使用operator <（或comp，如果提供）来比较值。

此函数模板（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)
}

参数

  1. a，b
    要比较的值。
  2. comp
    二进制函数，它接受两个类型为T的值作为参数，并返回一个可转换为bool的值。 返回的值指示作为第一个参数传递的元素是否小于第二个参数。该函数不得修改其任何参数。这可以是函数指针或函数对象。
  3. il
    initializer_list对象。这些对象是从初始化列表声明符自动构造的。

T应支持用operator <进行比较。：
【C++ 98】T应是可复制的。
【C++ 11】对于（3），T应是可复制的。

返回值

作为参数传递的值中较小的值。

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

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

在这里插入图片描述

二、max

头文件algorithm

【C++ 98】

default (1)	
template <class T> const T& max (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  const T& max (const T& a, const T& b, Compare comp);

【C++ 11】

default (1)	
template <class T> const T& max (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  const T& max (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T> T max (initializer_list<T> il);
template <class T, class Compare>
  T max (initializer_list<T> il, Compare comp);

【C++ 14】

default (1)	
template <class T> constexpr const T& max (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  constexpr const T& max (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T> constexpr T max (initializer_list<T> il);
template <class T, class Compare>
  constexpr T max (initializer_list<T> il, Compare comp);

返回最大的

返回a和b中的最大值。 如果两者都是等价的，则返回a。

初始化列表（3）的版本返回列表中所有元素中最大的一个。 如果这些不止一个，则返回第一个。

该函数使用operator <（或comp，如果提供）来比较值。

此函数模板（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)
}

参数

  1. a，b
    要比较的值。
  2. comp
    二进制函数，它接受两个类型为T的值作为参数，并返回一个可转换为bool的值。 返回的值指示作为第一个参数传递的元素是否小于第二个参数。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。
  3. il
    initializer_list对象。
    这些对象是从初始化列表声明符自动构造的。

T应支持用operator <进行比较：
【C++ 98】T应是可复制的。
【C++ 11】对于（3），T应是可复制的。

返回值

作为参数传递的最大值。

// max example
#include <iostream>     // std::cout
#include <algorithm>    // std::max

int main () {
  std::cout << "max(1,2)==" << std::max(1,2) << '\n';
  std::cout << "max(2,1)==" << std::max(2,1) << '\n';
  std::cout << "max('a','z')==" << std::max('a','z') << '\n';
  std::cout << "max(3.14,2.73)==" << std::max(3.14,2.73) << '\n';
  return 0;
}

在这里插入图片描述

三、minmax

头文件algorithm

【C++ 11】

default (1)	
template <class T>
  pair <const T&,const T&> minmax (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  pair <const T&,const T&> minmax (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T>
  pair<T,T> minmax (initializer_list<T> il);
template <class T, class Compare>
  pair<T,T> minmax (initializer_list<T> il, Compare comp);

【C++ 14】

default (1)	
template <class T>
  constexpr pair <const T&,const T&> minmax (const T& a, const T& b);
custom (2)	
template <class T, class Compare>
  constexpr pair <const T&,const T&> minmax (const T& a, const T& b, Compare comp);
initializer list (3)	
template <class T>
  constexpr pair<T,T> minmax (initializer_list<T> il);
template <class T, class Compare>
  constexpr pair<T,T> minmax (initializer_list<T> il, Compare comp);

返回最小和最大的元素

返回一对最小的a和b作为第一个元素，最大的作为第二个元素。 如果两者都是等价的，则函数返回make_pair（a，b）。

initializer lists (3)的版本返回一对，列表中所有元素中的最小元素作为第一个元素（第一个元素，如果有多个元素），最大的元素作为第二个元素（最后一个，如果有的话，最后一个，如果 不止一个）。

该函数使用operator <（或comp，如果提供）来比较值。

此函数模板（version (1)）的行为等效于：

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

参数

  1. a，b
    要比较的值。
  2. comp
    二进制函数，它接受两个类型为T的值作为参数，并返回一个可转换为bool的值。 返回的值指示作为第一个参数传递的元素是否小于第二个参数。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。
  3. il
    initializer_list对象。
    这些对象是从初始化列表声明符自动构造的。

T应支持用operator <进行比较。对于（3），T应是可复制的。

返回值

作为参数传递的值中较小的值。

// minmax example
#include <iostream>     // std::cout
#include <algorithm>    // std::minmax

int main () {
  auto result = std::minmax({1,2,3,4,5});

  std::cout << "minmax({1,2,3,4,5}): ";
  std::cout << result.first << ' ' << result.second << '\n';
  return 0;
}

在这里插入图片描述

四、min_element

头文件algorithm

default (1)	
template <class ForwardIterator>
  ForwardIterator min_element (ForwardIterator first, ForwardIterator last);
custom (2)	
template <class ForwardIterator, class Compare>
  ForwardIterator min_element (ForwardIterator first, ForwardIterator last, Compare comp);

返回范围内的最小元素

返回指向范围[first，last]中具有最小值的元素的迭代器。

比较是使用operator <作为第一个版本，或comp作为第二个版本; 如果没有其他元素比它少，则元素是最小的。 如果多个元素满足此条件，则迭代器返回指向第一个这样的元素。

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

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

参数

  1. fisrt，last
    将迭代器输入到要比较的序列的初始和最终位置。 使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
  2. comp
    二进制函数，接受范围中的两个元素作为参数，并返回可转换为bool的值。 返回的值指示作为第一个参数传递的元素是否小于第二个参数。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

迭代器到范围中的最小值，如果范围为空则为last。

// min_element/max_element example
#include <iostream>     // std::cout
#include <algorithm>    // std::min_element, std::max_element

bool myfn(int i, int j) { return i<j; }

struct myclass {
  bool operator() (int i,int j) { return i<j; }
} myobj;

int main () {
  int myints[] = {3,7,2,5,6,4,9};

  // using default comparison:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7) << '\n';

  // using function myfn as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myfn) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myfn) << '\n';

  // using object myobj as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myobj) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myobj) << '\n';

  return 0;
}

在这里插入图片描述

五、max_element

头文件algorithm

default (1)	
template <class ForwardIterator>
  ForwardIterator max_element (ForwardIterator first, ForwardIterator last);
custom (2)	
template <class ForwardIterator, class Compare>
  ForwardIterator max_element (ForwardIterator first, ForwardIterator last,
                               Compare comp);

返回范围内的最大元素

返回指向范围[first，last]中具有最大值的元素的迭代器。

比较是使用operator <作为第一个版本，或comp作为第二个版本; 如果没有其他元素没有比它少，则元素是最大的。 如果多个元素满足此条件，则迭代器返回指向第一个这样的元素。

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

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

参数

  1. first，last
    将迭代器输入到要比较的序列的初始和最终位置。 使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
  2. comp
    二进制函数，接受范围中的两个元素作为参数，并返回可转换为bool的值。 返回的值指示作为第一个参数传递的元素是否小于第二个参数。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

迭代器到范围中的最大值，如果范围为空则为last。

// min_element/max_element example
#include <iostream>     // std::cout
#include <algorithm>    // std::min_element, std::max_element

bool myfn(int i, int j) { return i<j; }

struct myclass {
  bool operator() (int i,int j) { return i<j; }
} myobj;

int main () {
  int myints[] = {3,7,2,5,6,4,9};

  // using default comparison:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7) << '\n';

  // using function myfn as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myfn) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myfn) << '\n';

  // using object myobj as comp:
  std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myobj) << '\n';
  std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myobj) << '\n';

  return 0;
}

在这里插入图片描述

六、minmax_element

头文件algorithm

default (1)	
template <class ForwardIterator>
  pair<ForwardIterator,ForwardIterator>
    minmax_element (ForwardIterator first, ForwardIterator last);
custom (2)	
template <class ForwardIterator, class Compare>
  pair<ForwardIterator,ForwardIterator>
    minmax_element (ForwardIterator first, ForwardIterator last, Compare comp);

返回范围内的最小和最大元素

返回一个迭代器对，该迭代器指向范围[first，last]中最小值为第一个元素的元素，最大值为第二个元素。

使用运算符<对于第一个版本执行比较，或对于第二个版本执行comp。

如果多个等效元素具有最小值，则第一个迭代器指向第一个这样的元素。

如果多个等效元素具有最大值，则第二个迭代器指向最后一个这样的元素。

参数

  1. first，last
    将迭代器输入到要比较的序列的初始和最终位置。 使用的范围是[first，last），它包含first和last之间的所有元素，包括first指向的元素，但不包括last指向的元素。
  2. comp
    二进制函数，接受范围中的两个元素作为参数，并返回可转换为bool的值。 返回的值指示作为第一个参数传递的元素是否小于第二个参数。
    该函数不得修改其任何参数。这可以是函数指针或函数对象。

返回值

具有迭代器的对，其指向具有[first，last]范围中的最小值的元素作为第一元素，并且最大值作为第二元素。

pair是中定义的类模板。

// minmax_element
#include <iostream>     // std::cout
#include <algorithm>    // std::minmax_element
#include <array>        // std::array

int main () {
  std::array<int,7> foo {3,7,2,9,5,8,6};

  auto result = std::minmax_element (foo.begin(),foo.end());

  // print result:
  std::cout << "min is " << *result.first;
  std::cout << ", at position " << (result.first-foo.begin()) << '\n';
  std::cout << "max is " << *result.second;
  std::cout << ", at position " << (result.second-foo.begin()) << '\n';

  return 0;
}

在这里插入图片描述

WilliamX2020
关注
专栏目录
C++ STL非更易型算法min_element、max_element、minmax_element使用方法
qq_44800780的博客
12-24 769
最小值和最大值 这些算法分别返回[_First,_Last)区间中的最小元素位置、最大元素位置.或最小和最大元素位置所组成的pair 上述没有_Pred实参的各个版本将以operator<进行元素比较 _Pred用来比较两个元素,_Pred(elem1,elem2)如果第一元素小于第二元素，应当返回true 如果存在多个最小值或最大值，min_element()和max_el...
C++中返回最大最小值的方法--min_element、max_element、max、min（很全）
居老师的博客
05-02 1700
1. max() 使用C++11，需要algorithm标准库 两个值的取最大值： max(a,b); 多个数取最大值： #include <iostream> #include <algorithm> using namespace std; int main() { int a = 1; int b = 2; int c = 3; cout << max({a, b, c}) << endl; return 0; } 2.
C++ min函数
weixin_30667649的博客
09-05 3万+
min 是c++标准库头文件中的一个重要的函数。它的功能是一个最小值的函数，比较两个数值的大小，返回他们的之间最小值. #include <algorithm> int a=2; int b=3; min(a,b); 转载于:https://www.cnblogs.com/chendeqiang/p/11465490.html...
minC++
qq_55192561的博客
10-16 1066
添加头文件：#include <algorithm> min(参数1,参数2)
C++求一个数据集的最大值和最小值详解
最新发布
程序猿老樊的博客
06-23 617
求一个数据集的最大值和最小值是常见的数据处理任务之一，主要用于了解数据的范围和分布情况。原理非常简单：遍历整个数据集，记录当前遇到的最大值和最小值。假设在处理一个温度传感器的数据集，想要知道一天中记录的最高和最低温度。通过这种方式，我们可以快速找出数据集中最大和最小的值，并应用于各种领域的数据分析任务中。(5).完成遍历后，最大值和最小值变量即为数据集中的最大值和最小值。(3).如果该元素大于当前记录的最大值，则更新最大值。(4).如果该元素小于当前记录的最小值，则更新最小值。
C++中min()、max()函数的使用
tyz_C的博客
02-07 4357
cout
c++最大值（max）函数和最小值（min）函数的使用方法
zhengddzz的博客
02-05 9844
请注意，通过比较和查找函数能够灵活地获取最大值和最小值，适用范围广泛，并且可以应用于不同类型的数据。同时，如果要在自定义类型或自定义类对象中查找最大值或最小值，您可能需要定义相关的比较函数或操作符。在 C++ 中，可以使用一些常用的算法函数和常量来获取最大值和最小值。这个函数接受两个参数 a 和 b，并返回其中较大的值。可以用于比较基本数据类型、自定义类型、字符串等。这个函数接受两个参数 a 和 b，并返回其中较小的值。可以用于比较基本数据类型、自定义类型、字符串等。
C++ min/max_element 函数用法详解
08-25
C++ 中的 min_element 和 max_element 函数是 STL 算法库中的两个重要函数，它们可以帮助开发者快速地查找序列中的最小元素和最大元素。这些函数广泛应用于各种算法和数据处理领域，具有很高的实用价值。 函数签名...
【C++基础】accumulate max_element min_element的使用
AloneYueCSDN
09-04 229
文章目录使用1.累加求和(针对数组或者容器中C++内置数据类型)2.累加求和(针对自定义数据类型结构体等) 使用 1.累加求和(针对数组或者容器中C++内置数据类型) int sum = accumulate(vec.begin() , vec.end() , 42); 1.前两个形参指定要累加的元素范围，第三个形参则是累加的初值。 2.accumulate函数将它的一个内部变量设置为指定的初始值，然后在此初值上累加输入范围内所有元素的值。accumulate算法返回累加的结果，其返回类型就是其第三
最小函数值(minval)
happy
08-17 1885
有n个函数，分别为F1,F2,…,Fn。定义Fi(x)=Ai*x^2+Bi*x+Ci(x∈N*)。给定这些Ai、Bi和Ci，请求出所有函数的所有函数值中最小的m个（如有重复的要输出多个）。 【输入格式】 第一行输入两个正整数n和m。 以下n行每行三个正整数，其中第i行的三个数分别位Ai、Bi和Ci。输入数据保证Ai<=10，Bi<=100，Ci<=10 000。 【输出格式】
c++中min函数_Excel中MIN函数的用法你都会了吗？
weixin_32541907的博客
01-25 1608
Excel是办公室工作的常用软件，相信很多小伙伴对其并不陌生，Excel之所以这么受欢迎，是因为其内置的函数和公式给使用者带来很大的方便。小编今天要跟大家分享的是MIN函数，它的功能是返回一组数值中的最小值，忽略逻辑及文本值。我们先看一个简单的例子，从图中我们可以看出需要求每一科的最低分，我们可以直接用=MIN(B3:B5)即可实现我们的要求。接下来我们看另外一个例子，从图中我们可以看出需要求一天...
C++中使用辅助函数寻找最大/最小值：min()、max()、minmax()
JunJie的个人博客
06-14 2万+
关于max()、min()、minmax() 三种接口的使用
C++--问题35--min和max函数和minmax函数的用法
数组越界，数组进栈
11-18 1万+
min和max函数和minmax函数的用法
min函数和与函数名相同的变量—在c++与matlab中的使用
believeLWN的专栏
03-08 2132
一.在c++中的使用 1.min函数的使用 min函数在c++中的应用，使用min函数时，需要加上algorithm头文件，可以实现比较两个数的大小。 #include&lt;iostream&gt; #include&lt;algorithm&gt; using namespace std; int main() { double a[2],mmin; a[0]=1; ...
C++ min()算法解析
先闻其声的博客
06-09 2万+
Min() 算法比较简单,它的作用是比较两个值大小然后返回最小值,可以先看下算法的定义: // TEMPLATE FUNCTION min template<class _Ty> inline _Post_equal_to_(_Right < _Left ? _Right : _Left) _CONST_FUN const _Ty& (min)(const _Ty&...
c++ 找最大值 最小值 函数
ooon
07-13 2万+
#include #include using namespace std; int main() { int n[]={1,4,22,3,8,5}; int len=sizeof(n)/sizeof(int); //数组长度 cout<<*max_element(n,n+len)<<endl; //找最大值 最小值 cout<<*min_element(n,n
c++ 求数组最大最小值函数
cyh
01-27 4万+
c++求数组元素最大最小值函数 #include #include using namespace std; int main() { int a[5]={1,2,3,0,-20}; cout cout return 0; } 也可以通过这种方式，修改最大值或最小值 #include #include using namespace std; int main()
c++中min和max函数
热门推荐
亦木的博客
04-12 24万+
包含在c++标准库中头文件中，在头文件中定义了min,max的宏，若在包含的同时包含会导致函数无法使用。 提供了_cpp_min等函数来代替min函数的功能。 C++11标准：中min函数的原型 default (1) template const T& min (const T& a, const T& b); custom (2) t
C++函数之 max和min
dengqingrui123的博客
09-08 3285
这是c++中基本的一种函数，希望大家多多学习
minmax_element minmax_element
05-10
`minmax_element` 是 C++ STL 中的一个函数，用于查找给定范围内的最小值和最大值。它的用法如下： ```cpp template<class ForwardIt> std::pair<ForwardIt,ForwardIt> minmax_element(ForwardIt first, ForwardIt last); ``` 其中 `first` 和 `last` 分别是要查找的范围的起始和终止迭代器，函数返回一个 `pair` 类型的值，其中 `pair.first` 是最小值的迭代器，`pair.second` 是最大值的迭代器。 例如，以下代码演示了如何使用 `minmax_element` 查找数组 `arr` 中的最小值和最大值： ```cpp #include <iostream> #include <algorithm> int main() { int arr[] = { 5, 3, 1, 4, 2 }; auto result = std::minmax_element(arr, arr + 5); std::cout << "Min element is: " << *result.first << "\n"; std::cout << "Max element is: " << *result.second << "\n"; return 0; } ``` 输出： ``` Min element is: 1 Max element is: 5 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值