벡터에서 최대 (또는 최소) 값을 어떻게 얻을 수 있습니까?

C ++ 에서 벡터의 최대 (또는 최소) 값을 어떻게 얻을 수 있습니까?

Google에서 이에 대한 몇 가지 해결책을 보았지만 어느 것도 나에게 의미가 없습니다.

누군가가 벡터에서 최대 또는 최소 값을 얻는 방법을 쉽고 간단하게 설명 할 수 있습니까? 그리고 그것이 배열과 다소 동일하다고 가정하는 것이 잘못입니까?

반복자가 필요합니까? 나는 그것을 시도 max_element했지만 계속 오류가 발생합니까?

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

오류 : 비 클래스 유형 'int [10]'인 'cloud'의 멤버 'begin'에 대한 요청

편집 : 나는 내 자신의 대답을 할 수 없었다 ??? 그래서 여기에 넣을 게요 ...

와우, 빠른 답변 감사합니다! 나는 이런 식으로 끝내고, 괜찮다고 생각합니까?

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

cdf벡터는 어디에 있습니까 ?

C ++ 11 / c ++ 0x 컴파일 플래그를 사용하여 다음을 수행 할 수 있습니다.

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

그렇지 않으면 직접 작성하십시오.

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

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

아, 그리고 한 번에 둘 다 필요한 경우 사용std::minmax_element(...) 하십시오 : /

함수를 사용하려는 경우 std::max_element()수행해야하는 방법은 다음과 같습니다.

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

도움이 되었기를 바랍니다.

허락하다,

 #include <vector>

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

벡터가 오름차순 또는 내림차순으로 정렬 된 경우 복잡성 O (1)로 찾을 수 있습니다.

오름차순 벡터의 경우 첫 번째 요소는 가장 작은 요소이고 v [0] (0 기반 인덱싱)로 가져올 수 있고 마지막 요소는 가장 큰 요소이며 v [sizeOfVector-1]로 가져올 수 있습니다.

벡터를 내림차순으로 정렬하면 마지막 요소가 가장 작은 요소이고 v [sizeOfVector-1]로 가져올 수 있고 첫 번째 요소가 가장 큰 요소이면 v [0]으로 가져올 수 있습니다.

벡터가 정렬되지 않은 경우 가장 작은 / 가장 큰 요소를 얻기 위해 벡터를 반복해야합니다.이 경우 시간 복잡도는 O (n)이고 여기서 n은 벡터의 크기입니다.

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

반복자를 사용할 수 있습니다.

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

입력 섹션에서 계산할 수 있습니다 (주어진 벡터에서 가장 작거나 가장 큰 요소를 찾아야 할 때)

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

또한 내장 함수로 가장 작은 / 가장 큰 요소를 얻을 수 있습니다.

#include<algorithm>

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

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

이 함수를 사용하여 모든 범위의 최소 / 최대 요소를 얻을 수 있습니다. 예 :

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 () 함수 앞에 별표 (*)를 사용했습니다. 둘 다 반복자를 반환하기 때문입니다. 모든 코드는 C ++로되어 있습니다.

클라우드가 int cloud[10]다음과 같이 할 수 있다고 가정 합니다. int *p = max_element(cloud, cloud + 10);

max_element / min_element 함수를 사용하여 직접 인쇄 할 수 있습니다. 예 :

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

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

C ++ 11에서는 다음과 같은 기능을 사용할 수 있습니다.

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

반복기를 사용 하려면 배열 로 새로 배치를 수행 할 수 있습니다 .

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

()마지막 에 a가 없다는 점에 유의하십시오 . 그러면 해당 메모리를 저장소로 사용하고 반복기와 같은 STL 기능이있는 배열 클래스가 생성됩니다.

(이것은 C ++ TR1 / C ++ 11입니다)

max_element를 사용하여 벡터의 최대 값을 얻을 수 있습니다. max_element는 범위에서 가장 큰 값으로 반복자를 반환하거나 범위가 비어있는 경우 마지막으로 반환합니다. 반복기는 포인터와 비슷하므로 (또는 포인터가 반복기의 한 형태라고 말할 수 있음) 값을 가져 오기 위해 앞에 *를 사용할 수 있습니다. 따라서 문제에 따라 벡터의 최대 요소를 다음과 같이 얻을 수 있습니다.

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

벡터 "구름"의 최대 요소를 제공합니다. 도움이 되었기를 바랍니다.

딱 이것:

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

완전한 nooby 방법 ... C