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

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