Come posso ottenere il valore massimo (o minimo) in un vettore?

Come posso ottenere il valore massimo (o minimo) in un vettore in C ++ ?

Ho visto alcune soluzioni per questo su Google, ma nessuna aveva senso per me :(

Qualcuno può spiegare in modo semplice e diretto come ottenere il valore massimo o minimo da un vettore, per favore? e mi sbaglio a presumere che sarebbe più o meno lo stesso con un array?

Ho bisogno di un iteratore, giusto? L'ho provato con max_elementma ho continuato a ricevere un errore?

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

errore: richiesta per il membro "inizio" in "cloud", che è di tipo non di classe "int [10]"

EDIT: non sono stato in grado di rispondere alla mia ??? quindi lo metto qui ...

Wow, grazie per le risposte veloci! Ho finito per farlo in questo modo, pensi che sia ok?

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

dov'è cdfun vettore.

Usando i flag di compilazione c ++ 11 / c ++ 0x, puoi farlo

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

Altrimenti, scrivi il tuo:

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

Guardalo dal vivo su 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, e usastd::minmax_element(...) se hai bisogno di entrambi contemporaneamente: /

Se vuoi usare la funzione std::max_element(), il modo in cui devi farlo è:

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

Spero che questo possa aiutare.

Permettere,

 #include <vector>

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

Se il vettore è ordinato in ordine crescente o decrescente, puoi trovarlo con complessità O (1).

Per un vettore di ordine crescente il primo elemento è l'elemento più piccolo, puoi ottenerlo da v [0] (indicizzazione basata su 0) e l'ultimo elemento è l'elemento più grande, puoi ottenerlo da v [sizeOfVector-1].

Se il vettore è ordinato in ordine decrescente, l'ultimo elemento è l'elemento più piccolo, puoi ottenerlo da v [sizeOfVector-1] e il primo elemento è l'elemento più grande, puoi ottenerlo da v [0].

Se il vettore non è ordinato, è necessario iterare sul vettore per ottenere l'elemento più piccolo / più grande. In questo caso la complessità temporale è O (n), qui n è la dimensione del vettore.

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

Puoi usare l'iteratore,

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

Puoi calcolarlo nella sezione di input (quando devi trovare l'elemento più piccolo o più grande da un dato vettore)

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

Inoltre puoi ottenere l'elemento più piccolo / più grande dalle funzioni incorporate

#include<algorithm>

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

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

È possibile ottenere l'elemento più piccolo / più grande di qualsiasi intervallo utilizzando questa funzione. ad esempio,

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)

Ho usato l'asterisco (*), prima delle funzioni min_element () / max_element (). Perché entrambi restituiscono l'iteratore. Tutti i codici sono in c ++.

Supponendo che il cloud sia int cloud[10]che puoi farlo in questo modo: int *p = max_element(cloud, cloud + 10);

Puoi stamparlo direttamente usando la funzione max_element / min_element. Per esempio:

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

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

In c ++ 11, puoi usare alcune funzioni come questa:

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

Se vuoi usare un iteratore, puoi fare un posizionamento nuovo con un array.

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

Notare la mancanza di un file () alla fine, questo è importante. Questo crea una classe array che utilizza quella memoria come memoria e dispone di funzionalità STL come iteratori.

(Questo è C ++ TR1 / C ++ 11 tra l'altro)

Puoi usare max_element per ottenere il valore massimo nel vettore. Max_element restituisce un iteratore al valore più grande nell'intervallo o l'ultimo se l'intervallo è vuoto. Poiché un iteratore è come i puntatori (o puoi dire che il puntatore è una forma di iteratore), puoi usare un * prima di esso per ottenere il valore. Quindi, secondo il problema, puoi ottenere l'elemento massimo in un vettore come:

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

Ti darà il massimo elemento nella tua "nuvola" vettoriale. Spero che sia d'aiuto.

Solo questo:

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

Il modo completo nooby ... in C