如何获得向量中的最大值（或最小值）？

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

我已经在Google上看到了一些解决方案，但是对我来说，这些解决方案都没有道理:(

有人可以用一种简单明了的方法解释如何从向量中获取最大值或最小值吗？我是否认为与数组大致相同会错吗？

我需要一个迭代器吧？我尝试过，max_element但一直出现错误？

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

在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(...)，请使用：/

如果要使用该函数std::max_element()，则必须采用以下方法：

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

希望对您有所帮助。

让，

 #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 ++。

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

您可以使用max_element / min_element函数直接打印它。例如：

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

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

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

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

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

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

（顺便说一下，这是C ++ TR1 / C ++ 11）

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

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

它将为您提供向量“云”中的最大元素。希望能帮助到你。

只是这个：

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

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

完整的nooby方式...在C语言中