我如何得到一个向量的最大值或最小值？

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

请收看 翻译: 奇芳，校对: 奇芳，校对: 奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳，奇芳台的现场直播:

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

哦，还有 使用 < a href = “ http://en.cpferences ence.com/w/cpp/method/minmax _ element”rel = “ noReferrer”> std::minmax_element(...) ，如果你同时需要这两个的话:/

假设云是 int cloud[10]，你可以这样做: int *p = max_element(cloud, cloud + 10);

如果要使用迭代器，可以使用数组执行 新的位置。

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

请注意最后没有 ()，这很重要。这将创建一个数组类，该类使用该内存作为其存储器，并具有类似迭代器的 STL 特性。

(顺便说一下，这是 C + + TR1/C + + 11)

在 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::max_element()，你必须这样做:

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

可以使用 max _ element 获取向量中的最大值。 Max _ element 将返回一个迭代器，以获得范围内的最大值，如果范围为空则返回 last。由于迭代器类似于指针(或者可以说指针是迭代器的一种形式) ，所以可以在它之前使用 * 来获取值。 因此，根据这个问题，你可以得到向量中的最大元素:

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

它将给出矢量“云”中的最大元素。 希望能有帮助。

您可以使用 Max _ element或 Min _ element函数直接打印它。

例如:

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


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

让,

 #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 ()函数之前使用了星号(*) ，因为它们都返回迭代器。

就这样:

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

_{代表作者回答}

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

其中 cdf是一个矢量。