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

Question

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

我已经看到了这对谷歌的几个解决方案，但没有人对我有意义:(

有人能在一个简单直接的方式小白如何从矢量获得最大或最小值，请解释一下吗？ 和我是在错误的假设它会或多或少与数组一样吗？

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

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

错误：在“云”请求构件“开始”，其是非类类型“INT [10]”

编辑：我不能回答您自己的???所以我会把它放在这里...

哇，谢谢你的快速回复！ 我最终这样做，认为它好吗？

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

其中cdf是一个向量。

Answer 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(...)如果你需要两者兼而有之：/

Answer 2

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

Answer 3

如果你想使用一个迭代器，你可以做一个投放新与阵列。

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

注意最后缺少()，这很重要。这会创建一个使用该内存作为存储的数组类，并具有迭代器之类的STL特性。

（这是C++ TR1/C++ 11的方式）

Answer 4

#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

Answer 5

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

Answer 6

如果你想使用的功能std::max_element()，你必须做的方式是：

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

我希望这可以帮助。

Answer 7

您可以使用max_element获取向量中的最大值。 max_element将迭代器返回到范围中的最大值，如果范围为空，则返回最后一个值。作为一个迭代器就像指针（或者你可以说指针是一个迭代器的形式），你可以在它之前使用*来获取值。 所以按这个问题，你可以在一个矢量得到最大的元素：

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

它会给你在你的载体“云”的最大元素。 希望它有帮助。

Answer 8

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

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

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

Answer 9

令，

#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<sizeOfVector;i++) //start iterating from the second element 
{ 
if(v[i]<smallest_element) 
    { 
     smallest_element=arr[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++中。