Comment obtenir la valeur maximale ou minimale d'un vecteur ?

Question

Comment obtenir la valeur maximale ou minimale d'un vecteur en C++ ?

Et ai-je tort de penser que ce serait plus ou moins la même chose avec un tableau ?

J'ai besoin d'un itérateur, non ? J'ai essayé avec max_element mais je continue à avoir une erreur.

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]’

Answer 1

En utilisant les drapeaux de compilation de C++11/C++0x, vous pouvez

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

Sinon, écrivez le vôtre :

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

Voir le spectacle en direct à 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';
}

Oh, et utiliser std::minmax_element(...) si vous avez besoin des deux à la fois :/

Answer 2

Si vous voulez utiliser la fonction std::max_element() la façon dont vous devez le faire est :

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

Answer 3

Laissez,

 #include <vector>

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

Si le vecteur est trié par ordre croissant ou décroissant, vous pouvez le trouver avec une complexité O(1).

Pour un vecteur d'ordre croissant, le premier élément est le plus petit élément, vous pouvez l'obtenir par v[0] (indexation basée sur 0) et le dernier élément est le plus grand élément, vous pouvez l'obtenir par v[sizeOfVector-1].

Si le vecteur est trié par ordre décroissant, alors le dernier élément est le plus petit élément, vous pouvez l'obtenir par v[sizeOfVector-1] et le premier élément est le plus grand élément, vous pouvez l'obtenir par v[0].

Si le vecteur n'est pas trié, il faut alors itérer sur le vecteur pour obtenir le plus petit/le plus grand élément. Dans ce cas, la complexité temporelle est O(n), n étant la taille du vecteur.

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

Vous pouvez utiliser un itérateur,

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

Vous pouvez le calculer dans la section d'entrée (lorsque vous devez trouver le plus petit ou le plus grand élément d'un vecteur donné).

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

Vous pouvez également obtenir l'élément le plus petit/le plus grand grâce à des fonctions intégrées.

#include<algorithm>

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

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

Vous pouvez obtenir l'élément le plus petit/le plus grand de n'importe quelle plage en utilisant cette fonction. par exemple,

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)

J'ai utilisé l'astérisque (*), avant les fonctions min_element()/max_element(). Parce que les deux retournent un itérateur. Tous les codes sont en c++.

Answer 4

Vous pouvez l'imprimer directement en utilisant le max_élément o min_élément fonction.

Par exemple :

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

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

Answer 5

En supposant que le nuage est int cloud[10] vous pouvez le faire comme ceci : int *p = max_element(cloud, cloud + 10);