Comment puis-je obtenir la valeur max (ou min) dans un vecteur?

Comment puis-je obtenir la valeur max (ou min) dans un vecteur en C ++ ?

J'ai vu quelques solutions pour cela sur Google mais aucune d'entre elles n'a de sens pour moi :(

Quelqu'un peut-il expliquer d'une manière simple et directe comment obtenir la valeur maximale ou minimale d'un vecteur s'il vous plaît? et ai-je tort de supposer que ce serait plus ou moins la même chose avec un tableau?

J'ai besoin d'un itérateur, non? Je l'ai essayé avec max_elementmais j'ai continué à recevoir une erreur?

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

erreur: demande du membre 'begin' dans 'cloud', qui est de type non-classe 'int [10]'

EDIT: je n'ai pas pu répondre à la mienne ??? donc je vais le mettre ici ...

Wow, merci pour les réponses rapides! J'ai fini par le faire de cette façon, tu crois que c'est ok?

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

où cdfest un vecteur.

En utilisant les indicateurs de compilation 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; }

Voyez-le en direct sur 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 utilisezstd::minmax_element(...) si vous avez besoin des deux à la fois: /

Si vous souhaitez 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;

J'espère que cela peut aider.

Laisser,

 #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 la 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, 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é, vous devez itérer sur le vecteur pour obtenir le plus petit / le plus grand élément.Dans ce cas, la complexité temporelle est O (n), ici n est 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 l'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 le plus petit / le plus grand élément par 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 le plus petit / le plus grand élément de n'importe quelle plage en utilisant ces fonctions. tel que,

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 renvoient l'itérateur. Tous les codes sont en c ++.

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

Vous pouvez l'imprimer directement en utilisant la fonction max_element / min_element. Par exemple:

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

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

En c ++ 11, vous pouvez utiliser une fonction comme celle-ci:

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

Si vous souhaitez utiliser un itérateur, vous pouvez effectuer un nouveau placement avec un tableau.

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

Notez l'absence d'un () à la fin, c'est important. Cela crée une classe de tableau qui utilise cette mémoire comme stockage et possède des fonctionnalités STL telles que les itérateurs.

(C'est C ++ TR1 / C ++ 11 d'ailleurs)

Vous pouvez utiliser max_element pour obtenir la valeur maximale de vector. L'élément max_element renvoie un itérateur à la plus grande valeur de la plage, ou en dernier si la plage est vide. Comme un itérateur est comme des pointeurs (ou vous pouvez dire que le pointeur est une forme d'itérateur), vous pouvez utiliser un * devant lui pour obtenir la valeur. Donc, selon le problème, vous pouvez obtenir l'élément maximum dans un vecteur comme:

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

Cela vous donnera l'élément maximum dans votre vecteur "nuage". J'espère que ça aide.

Juste ça:

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

La manière nooby complète ... en C