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

Question

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

Ho visto un paio di soluzioni per questo su Google, ma nessuno di loro aveva senso per me :(

Qualcuno può spiegare in modo semplice niubbo semplice come ottenere il massimo o il valore minimo da un vettore per favore? e io sono sbagliato nel ritenere che sarebbe stato più o meno lo stesso con un array?

ho bisogno di un diritto iteratore? ho provato con max_element ma continuato a ottenere un errore?

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

errore: richiesta di membro ‘inizio’ a ‘nuvola’, che è di tipo non-class ‘int [10]’

EDIT: non ero 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]; 

dove cdf è un vettore.

Answer 1

utilizzando C++ 11/C++ 0x compilare bandiere, è possibile

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

In caso contrario, scrivere il proprio:

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

vederla dal vivo a 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 utilizzare std::minmax_element(...) se avete bisogno di entrambi contemporaneamente:/

Answer 2

Supponendo nube è int cloud[10] si può fare in questo modo: int *p = max_element(cloud, cloud + 10);

Answer 3

Se si desidera utilizzare un iteratore, si può fare un posizionamento nuovo con una array.

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

Nota la mancanza di un () alla fine, che è importante. Questo crea una classe array che usa quella memoria come sua memoria e ha caratteristiche STL come gli iteratori.

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

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

Il complet modo nooby ...in C

Answer 5

in C++ 11, è possibile utilizzare alcune funzioni del genere:

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

Se si desidera utilizzare la funzione di std::max_element(), il modo in cui si deve fare è:

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

Spero che questo possa aiutare.

Answer 7

È possibile utilizzare max_element per ottenere il valore massimo nel vettore. Il max_element restituisce un iteratore al valore più grande nell'intervallo o durerà se l'intervallo è vuoto. Poiché un iteratore è come i puntatori (o si può dire che il puntatore è una forma di iteratore), è possibile utilizzare un * prima di esso per ottenere il valore. Così come per il problema che si può ottenere il massimo elemento in un vettore come:

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

che vi darà l'elemento massimo nel vostro vettore "nuvola". Spero che aiuti.

Answer 8

È possibile stampare direttamente utilizzando la funzione max_element/min_element. Ad esempio:

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

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

Answer 9

Let,

#include<vector> 

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

Se il vettore è ordinato in ordine crescente o decrescente, allora si può trovare con la complessità O (1).

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

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

Se il vettore non è ordinato, è necessario eseguire un'iterazione 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<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]; 
    } 
} 

È possibile utilizzare 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; 
    } 
} 

Si può calcolare in sezione di ingresso (quando si deve trovare elemento più piccolo o più grande da un determinato 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 è può ottenere l'elemento più piccolo/più grande con funzioni integrate

#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 queste funzioni. come,

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 asterisco (*), prima che le funzioni min_element()/(max_element). Perché entrambi restituiscono iteratore. Tutti i codici sono in C++.