Bir vektördeki maksimum (veya minimum) değeri nasıl elde edebilirim?

C ++ 'da bir vektördeki maksimum (veya minimum) değeri nasıl alabilirim ?

Google'da bunun için birkaç çözüm gördüm ama hiçbiri bana mantıklı gelmedi :(

Biri bir vektörden maksimum veya minimum değeri nasıl elde edeceğini kolay ve basit bir şekilde açıklayabilir mi? ve bir dizi ile aşağı yukarı aynı olacağını varsaymakta hatalı mıyım?

Bir yineleyiciye ihtiyacım var değil mi? Denedim max_elementama hata almaya devam ettim ?

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

hata: sınıf tipi olmayan 'int [10]' olan 'bulut'ta' üye 'isteği

DÜZENLEME: Kendi cevap veremedim ??? bu yüzden buraya koyacağım ...

Vay canına, hızlı cevaplar için teşekkürler! Bunu bu şekilde yaptım, tamam mı dersin?

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

cdfvektör nerede .

C ++ 11 / c ++ 0x derleme bayraklarını kullanarak şunları yapabilirsiniz:

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

Aksi takdirde, kendi ifadenizi yazın:

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

O canlı görün 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, ve ikisine birden ihtiyacınız varsa kullanınstd::minmax_element(...) : /

İşlevi kullanmak istiyorsanız std::max_element(), yapmanız gereken yol:

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

Umarım bu yardımcı olabilir.

İzin Vermek,

 #include <vector>

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

Vektör artan veya azalan sırada sıralanırsa, onu karmaşıklık O (1) ile bulabilirsiniz.

Artan sıralı bir vektör için ilk eleman en küçük elemandır, bunu v [0] (0 tabanlı indeksleme) ile elde edebilirsiniz ve son eleman en büyük elemandır, v [sizeOfVector-1] ile elde edebilirsiniz.

Vektör azalan sırada sıralanırsa, son eleman en küçük elemandır, onu v [sizeOfVector-1] ile elde edebilirsiniz ve ilk eleman en büyük elemandır, onu v [0] ile elde edebilirsiniz.

Vektör sıralanmamışsa, en küçük / en büyük elemanı elde etmek için vektör üzerinde yineleme yapmanız gerekir. Bu durumda zaman karmaşıklığı O (n), burada n vektörün boyutudur.

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

Yineleyiciyi kullanabilirsiniz,

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

Giriş bölümünde hesaplayabilirsiniz (belirli bir vektörden en küçük veya en büyük elemanı bulmanız gerektiğinde)

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

Ayrıca yerleşik işlevlerle en küçük / en büyük elemanı elde edebilirsiniz

#include<algorithm>

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

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

Bu işlevleri kullanarak herhangi bir aralığın en küçük / en büyük elemanını elde edebilirsiniz. gibi,

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)

Min_element () / max_element () işlevlerinden önce yıldız (*) kullandım. Çünkü ikisi de yineleyici döndürür. Tüm kodlar c ++ 'dır.

Bulutun int cloud[10]bunu şu şekilde yapabileceğini varsayarsak : int *p = max_element(cloud, cloud + 10);

Max_element / min_element işlevini kullanarak doğrudan yazdırabilirsiniz. Örneğin:

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

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

C ++ 11'de, bunun gibi bazı işlevleri kullanabilirsiniz:

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

Yineleyici kullanmak istiyorsanız, bir dizi ile yeni bir yerleşim yapabilirsiniz .

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

()Sonunda a eksikliğine dikkat edin, bu önemlidir. Bu, belleği deposu olarak kullanan ve yineleyiciler gibi STL özelliklerine sahip bir dizi sınıfı oluşturur.

(Bu arada C ++ TR1 / C ++ 11)

Vektördeki maksimum değeri elde etmek için max_element kullanabilirsiniz. Max_element, aralıktaki en büyük değere bir yineleyici döndürür veya aralık boşsa sonuncu. Yineleyici işaretçiler gibi olduğundan (veya işaretçinin bir yineleyici biçimi olduğunu söyleyebilirsiniz), değeri almak için ondan önce * kullanabilirsiniz. Dolayısıyla, probleme göre, bir vektördeki maksimum elemanı şu şekilde elde edebilirsiniz:

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

Size "bulut" vektörünüzdeki maksimum öğeyi verecektir. Umarım yardımcı olur.

Sadece bu:

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

Tamamen nooby yolu ... C