如何获得向量中的最大值或最小值？答案

【问题标题】：How can I get the maximum or minimum value in a vector?如何获得向量中的最大值或最小值？
【发布时间】：2012-04-10 02:44:58
【问题描述】：

如何在 C++ 中获取向量中的最大值或最小值？

我假设它与数组或多或少相同，我错了吗？

我需要一个迭代器，对吧？我用max_element 尝试过，但一直出错。

vector<int>::const_iterator it;
it = max_element(cloud.begin(), cloud.end());

error: request for member ‘begin’ in ‘cloud’, which is of non-class type ‘int [10]’

【问题讨论】：

看起来 cloud 不是一个 STL 容器，而是一个 int[10]。基本上，cloud 没有成员 .begin()。除非你只做这件事，否则可能想要一本基本的 C++ 书籍。
更多代码也可能有用。云的定义在哪里？
@bobblob：但您发布的编译器错误说“云属于非类类型int[10]”。那怎么可能是向量呢？

标签： c++ vector max min

【解决方案1】：

使用 C++11/C++0x 编译标志，可以

auto it = max_element(std::begin(cloud), std::end(cloud)); // C++11

否则，请自己编写：

template <typename T, size_t N> const T* mybegin(const T (&a)[N]) { return a; }
template <typename T, size_t N> const T* myend  (const T (&a)[N]) { return a+N; }

在 http://ideone.com/aDkhW 观看直播：

#include <iostream>
#include <algorithm>

template <typename T, size_t N> const T* mybegin(const T (&a)[N]) { return a; }
template <typename T, size_t N> const T* myend  (const T (&a)[N]) { return a+N; }

int main()
{
    const int cloud[] = { 1,2,3,4,-7,999,5,6 };

    std::cout << *std::max_element(mybegin(cloud), myend(cloud)) << '\n';
    std::cout << *std::min_element(mybegin(cloud), myend(cloud)) << '\n';
}

哦，如果您同时需要两者，请使用std::minmax_element(...)：/

【讨论】：

您好，您知道是否可以将其应用于维度数组或向量？
是的，你可以。标准库算法被设计为在迭代器上通用。指针也是迭代器。

【解决方案2】：

假设云是int cloud[10]，你可以这样做： int *p = max_element(cloud, cloud + 10);

【讨论】：

也要试试这个。我早些时候尝试获得 max_element 但没有爱。谢谢！

【解决方案3】：

如果你想使用一个迭代器，你可以用一个数组做一个placement-new。

std::array<int, 10> icloud = new (cloud) std::array<int,10>;

请注意末尾缺少()，这很重要。这将创建一个使用该内存作为存储的数组类，并具有迭代器等 STL 功能。

（这是C++ TR1/C++11）

【讨论】：

new 返回一个指针，而不是一个值——所以std;:array<int, 10> icloud = new ... 是一个编译错误。此外，一旦您在没有初始化值的情况下调用任何类型的new（放置或其他），检查这些值是未定义的行为。即使这是在相同大小的值数组之上，但读取这些值违反了标准，编译器可以随意将此代码视为无效（可能会优化它，删除它等）

【解决方案4】：

在 C++11 中，您可以使用类似的函数：

int maxAt(std::vector<int>& vector_name) {
    int max = INT_MIN;
    for (auto val : vector_name) {
         if (max < val) max = val;
    }
    return max;
}

【讨论】：

由于您引用的是 C++11，这比使用 std::max_element 更好，因为...？
为什么标准库中有内置/标准算法？

【解决方案5】：

如果你想使用std::max_element()这个函数，你必须这样做：

double max = *max_element(vector.begin(), vector.end());
cout<<"Max value: "<<max<<endl;

【讨论】：

为什么*max_element中有*？
那是因为 ´max_element´ 返回一个迭代器
我猜你已经假设输入是 vector 或者 *max_element() 默认返回 double val。
确保您始终放置代码 sn-p 所需的#include 文件。另外：将向量称为“向量”可能不是一个好主意——它不是保留关键字，而是关闭！
太棒了！这次真是万分感谢。更简洁，实际上回答了一个问题。

【解决方案6】：

您可以使用 max_element 来获取向量中的最大值。 max_element 返回范围内最大值的迭代器，如果范围为空，则返回最后一个。由于迭代器就像指针（或者您可以说指针是迭代器的一种形式），您可以在它之前使用 * 来获取值。因此，根据问题，您可以获得向量中的最大元素：

int max=*max_element(cloud.begin(), cloud.end());

它将为您提供矢量“云”中的最大元素。希望对您有所帮助。

【讨论】：

确保您始终将代码 sn-p 所需的#include 文件放入

【解决方案7】：

您可以直接使用 max_element 或 min_element 函数进行打印。

例如：

cout << *max_element(v.begin(), v.end());

cout << *min_element(v.begin(), v.end());

【讨论】：

【解决方案8】：

让，

 #include <vector>

 vector<int> v {1, 2, 3, -1, -2, -3};

如果向量是按升序或降序排序的，那么你可以找到它的复杂度 O(1)。

对于升序的向量，第一个元素是最小元素，可以通过v[0]（基于0的索引）获取，最后一个元素是最大元素，可以通过v[sizeOfVector-1]获取.

如果向量按降序排列，则最后一个元素是最小的元素，可以通过v[sizeOfVector-1]得到，第一个元素是最大的元素，可以通过v[0]得到。

如果向量未排序，则必须遍历向量以获得最小/最大元素。在这种情况下，时间复杂度为 O(n)，这里 n 是向量的大小。

int smallest_element = v[0]; //let, first element is the smallest one
int largest_element = v[0]; //also let, first element is the biggest one
for(int i = 1; i < v.size(); i++)  //start iterating from the second element
{
    if(v[i] < smallest_element)
    {
       smallest_element = v[i];
    }
    if(v[i] > largest_element)
    {
       largest_element = v[i];
    }
}

你可以使用迭代器，

for (vector<int>:: iterator it = v.begin(); it != v.end(); it++)
{
    if(*it < smallest_element) //used *it (with asterisk), because it's an iterator
    {
      smallest_element = *it;
    }
    if(*it > largest_element)
    {
      largest_element = *it;
    }
}

您可以在输入部分计算它（当您必须从给定向量中找到最小或最大元素时）

int smallest_element, largest_element, value;
vector <int> v;
int n;//n is the number of elements to enter
cin >> n;
for(int i = 0;i<n;i++)
{
    cin>>value;
    if(i==0)
    {
        smallest_element= value; //smallest_element=v[0];
        largest_element= value; //also, largest_element = v[0]
    }

    if(value<smallest_element and i>0)
    {
        smallest_element = value;
    }

    if(value>largest_element and i>0)
    {
        largest_element = value;
    }
    v.push_back(value);
}

您还可以通过内置函数获取最小/最大元素

#include<algorithm>

int smallest_element = *min_element(v.begin(),v.end());

int largest_element  = *max_element(v.begin(),v.end());

您可以使用此函数获取任何范围的最小/最大元素。比如，

vector<int> v {1,2,3,-1,-2,-3};

cout << *min_element(v.begin(), v.begin() + 3); //this will print 1,smallest element of first three elements

cout << *max_element(v.begin(), v.begin() + 3); //largest element of first three elements

cout << *min_element(v.begin() + 2, v.begin() + 5); // -2, smallest element between third and fifth element (inclusive)

cout << *max_element(v.begin() + 2, v.begin()+5); //largest element between third and first element (inclusive)

我在 min_element()/max_element() 函数之前使用了星号 (*)。因为它们都返回迭代器。所有代码都是c++。

【讨论】：

min_element 和 max_element 返回一个迭代器，而不是一个指针。但是，从技术上讲，指针是迭代器的子集。见：stackoverflow.com/questions/2728190/…
我已经更新了我的答案。感谢您的观察。

【解决方案9】：

就这个：

// assuming "cloud" is:
// int cloud[10]; 
// or any other fixed size

#define countof(x) (sizeof(x)/sizeof((x)[0]))

int* pMax = std::max_element(cloud, cloud + countof(cloud));

【讨论】：

为什么要使用宏？没有理由这样做！错误以int cloud[10];开头，是使用了幻数。
因为从错误消息中可以清楚地看出他没有向量而是普通数组。你必须以某种方式计算它的长度，以避免使用硬编码的幻数。他将来可能会更改长度，但以这种方式找到最大值的代码将是相同的。
抱歉，没有正确理解。您的解决方案是正确的，但很糟糕。原因是它假设使用幻数，而这并没有从错误消息中得出。然后继续使用宏，这总是一种代码味道。
理论上宏可以扩展到代码中，但我更愿意将其保留为很少“有用”的宏。而且，一些供应商甚至做OOB。例如，Visial C++ 提供与上述类似的 OOB "_countof"。如果您知道如何使用元编程做同样的事情，但同样简短而优雅，请发布您的代码示例。

【解决方案10】：

_{代作者回答}

for (unsigned int i = 0; i < cdf.size(); i++)
  if (cdf[i] < cdfMin)
    cdfMin = cdf[i];

cdf 是一个向量。

【讨论】：