c++ - una - programacion en c maximo y minimo

¿Cómo puedo obtener el valor máximo(o mínimo) en un vector?

Question

¿Cómo puedo obtener el valor máximo (o mínimo) en un vector en C ++ ?

He visto algunas soluciones para esto en Google, pero ninguna de ellas tiene sentido para mí :(

¿Puede alguien explicar de una manera fácil y sencilla cómo obtener el valor máximo o mínimo de un vector, por favor? y ¿me equivoco al suponer que sería más o menos lo mismo con una matriz?

Necesito un iterador, ¿verdad? Lo intenté con max_element pero seguí recibiendo un error?

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

error: solicitud de miembro ''begin'' en ''cloud'', que es de tipo no de clase ''int [10]''

EDITAR: ¿No pude responder el mío? así que lo pondré aquí ...

Wow, gracias por las respuestas rápidas! Terminé haciéndolo de esta manera, ¿crees que está bien?

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

donde cdf es un vector.

Answer 1

Dejar,

 #include<vector>

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

Si el vector está ordenado en orden ascendente o descendente, entonces puede encontrarlo con complejidad O (1).

Para un vector de orden ascendente, el primer elemento es el más pequeño, puede obtenerlo por v [0] (indexación basada en 0) y el último elemento es el más grande, puede obtenerlo v [sizeOfVector-1].

Si el vector está ordenado en orden descendente, entonces el último elemento es el más pequeño, puede obtenerlo v [sizeOfVector-1] y el primer elemento es el más grande, puede obtenerlo v [0].

Si el vector no está ordenado, entonces debe iterar sobre el vector para obtener el elemento más pequeño / más grande. En este caso, la complejidad del tiempo es O (n), aquí n es el tamaño del vector.

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

Puedes usar iterador,

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

Puedes calcularlo en la sección de entrada (cuando tienes que encontrar el elemento más pequeño o más grande de un vector dado)

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

También puede obtener el elemento más pequeño / más grande mediante funciones integradas

#include<algorithm>

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

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

Puede obtener el elemento más pequeño / más grande de cualquier rango mediante el uso de estas funciones. como,

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)

He usado asterisco (*), antes funciones min_element () / max_element (). Porque ambos devuelven el iterador. Todos los códigos están en c ++.

Answer 2

En c ++ 11, puede usar alguna función como esa:

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

Answer 3

Puede imprimirlo directamente utilizando la función max_element / min_element. P.ej:

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

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

Answer 4

Puede usar max_element para obtener el valor máximo en vector. Max_element devuelve un iterador al valor más grande en el rango o último si el rango está vacío. Como un iterador es como punteros (o puede decir que el puntero es una forma de iterador), puede usar un * antes de obtener el valor. Entonces, según el problema, puedes obtener el elemento máximo en un vector como:

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

Le dará el máximo elemento en su vector "nube". Espero eso ayude.

Answer 5

Si desea usar la función std::max_element() , la forma en que debe hacerlo es:

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

Espero que esto pueda ayudar.

Answer 6

Si desea utilizar un iterador, puede hacer una ubicación-nueva con una matriz.

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

Tenga en cuenta la falta de un () al final, eso es importante. Esto crea una clase de matriz que usa esa memoria como su almacenamiento y tiene características STL como iteradores.

(Esto es C ++ TR1 / C ++ 11 por cierto)

Answer 7

Suponiendo que la nube es una nube int cloud[10] , puede hacerlo así: int *p = max_element(cloud, cloud + 10);

Answer 8

Utilizando indicadores de compilación c ++ 11 / c ++ 0x, puede

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

De lo contrario, escribe la tuya:

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

Véalo en vivo en 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'';
}

Ah, y use std::minmax_element(...) si necesita ambos a la vez: /

Answer 9

#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 forma completa de nooby ... en C