C++ 如何获得向量中的最大（或最小）值？ #include <stdlib.h> #include <stdio.h> int main() { int vector[500]; vector[0] = 100; vector[1] = 2; vector[2] = 1239; vector[3] = 5; vector[4] = 10; vector[5] = 1; vector[6] = 123; vector[7] = 1000; vector[8] = 9; vector[9] = 123; vector[10] = 10; int i = 0; int winner = vector[0]; for(i=0;i < 10; i++) { printf("vector = %d \n", vector[i]); if(winner > vector[i]) { printf("winner was %d \n", winner); winner = vector[i]; printf("but now is %d \n", winner); } } printf("the minimu is %d", winner); }

我在谷歌上看到了一些解决方案，但没有一个对我有意义：

有人能用一种简单明了的方法解释一下如何从向量中得到最大值或最小值吗？ 我是否错误地认为它与数组大致相同

我需要一个迭代器，对吗？我用max_元素尝试了一下，但一直出错

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

错误：请求“cloud”中的成员“begin”，该成员属于非类类型“int[10]”

编辑：我无法回答我自己的问题？？？所以我会把它放在这里

哇，谢谢你的快速回复！ 我最后就这样做了，你觉得可以吗

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

---

其中cdf是一个向量。

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

现场观看：

哦，如果您同时需要这两种云，请使用：/

假设cloud是int cloud[10]，您可以这样做：

---

int*p=最大元素云，云+10

如果要使用迭代器，可以使用数组进行新的放置

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

请注意，在结尾处缺少a，这一点很重要。这将创建一个数组类，该类使用该内存作为其存储，并具有类似迭代器的STL功能

这是C++ Tr1/C++ 11的方式< /P>

#include <stdlib.h>
#include <stdio.h>

int main()
{

    int vector[500];

    vector[0] = 100;
    vector[1] = 2;
    vector[2] = 1239;
    vector[3] = 5;
    vector[4] = 10;
    vector[5] = 1;
    vector[6] = 123;
    vector[7] = 1000;
    vector[8] = 9;
    vector[9] = 123;
    vector[10] = 10;

    int i = 0;

    int winner = vector[0];

    for(i=0;i < 10; i++)
    {
        printf("vector = %d \n", vector[i]);

        if(winner > vector[i])
        {
            printf("winner was %d \n", winner);
            winner = vector[i];
            printf("but now is %d \n", winner);
        }
    }

    printf("the minimu is %d", winner);
}

---

顺便说一句，完整的Noot。。。在C++11的C

中，您可以使用如下函数：

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

---

如果要使用函数std:：max_元素，必须采用以下方法：

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

---

我希望这能有所帮助。

您可以使用max\u元素获得向量中的最大值。 max_元素返回一个迭代器，该迭代器返回范围内的最大值，如果范围为空，则返回最后一个值。由于迭代器类似于指针，或者可以说指针是迭代器的一种形式，所以可以在它前面使用*来获取值。 根据这个问题，你可以得到向量中的最大元素，如下所示：

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

它将为您提供矢量云中的最大元素。

---

希望有帮助。

您可以使用max\u element/min\u element功能直接打印。 例如：

让,

如果向量按升序或降序排序，那么您可以找到复杂度为O1的向量

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

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

如果向量未排序，则必须迭代向量以获得最小/最大的元素。在这种情况下，时间复杂度为On，这里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)

我在最小元素/最大元素函数之前使用了星号*。因为它们都返回迭代器。所有代码都是C++的。p> 就这样：

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

---

看起来cloud不是STL容器，而是int[10]。基本上，云没有成员。开始吧。可能只想得到一本基本的C++书籍，除非你只做这件事。cloud的定义在哪里？@bobblob:但是你发布的编译器错误说cloud是非类类型int[10]。那怎么可能是矢量呢？我也要试试这个。我早些时候试着得到max_元素，但没有得到爱。谢谢这回答了如何在数组中找到最大值的问题，而不是C++向量。这个问题是标记C++。您已经用C编写了这段代码，但不仅如此，您将向量等同于数组——这是不正确的。当我们只需要实际值时，也有不必要的打印语句。最后，整个代码让人分心。您只需要for循环中的代码。总的来说，这是一个非常糟糕的答案。嗨，你知道有没有可能把它应用到维数组或向量中？是的，你可以。标准库算法被设计为一般地在迭代器上工作。指针也是迭代器。为什么*max_元素中有*呢？这是因为` max_元素'返回一个迭代器，或者您假设输入是向量，或者*max_元素默认返回双val。请确保始终放置代码段所需的包含文件。另外：调用vector可能不是一个好主意——它不是一个保留关键字，但很接近！因为您正在引用C++11，所以这比使用std:：max\u元素要好，因为…？min\u元素和max\u元素返回的是迭代器，而不是指针。然而，从技术上讲，指针是迭代器的子集。见：我已经更新了我的答案。感谢您的观察。为什么要使用宏？没有理由！错误以int cloud[10]开头；这是使用魔法麻木

---

因为从错误信息可以清楚地看出，他并没有向量，而是正规数组。你必须以某种方式计算它的长度，以避免使用硬编码的幻数。他可能会在将来更改长度，但用这种方法查找最大值的代码将是相同的。抱歉，这没有正确理解。你的解决方案是正确的，但很糟糕。原因是它假设使用了幻数，而这不是错误消息的结果。然后继续使用宏，宏总是一种代码味道。理论上，宏可以扩展到代码中，但我更愿意将其保留为很少有用的宏。此外，一些供应商甚至做它OOB。例如，Visual C++提供了OOB的一个模拟实例。如果您知道如何使用元编程实现同样的功能，但同样简短优雅，请发布您的代码示例。请确保始终放置代码段所需的包含文件

#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)

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