与 min_element 和 max_element 一起使用 minmax_element 是否有任何效率优势？

Question

std::minmax_element ：返回一个对，其中包含一个指向最小元素的迭代器作为第一个元素，一个指向最大元素的迭代器作为第二个元素。

std::min_element ：返回一个迭代器，指向范围 [first, last) 中的最小元素。

std::max_element ：返回一个迭代器，指向范围 [first, last) 中的最大元素。

---

std::minmax_element 是否使用完整列表的排序 来实现此目的？

处理来自std::minmax_element 的返回对的开销是否足够？

Answer 1

您不必担心std::minmax_element 进行任何排序。它以它被遍历的确切方式离开范围。它更高效的原因是它可以在一次通过中找到最大值和最小值，而当分别查找最大值和最小值时，您必须进行两次完整遍历。

std::minmax_element 具有 max(floor(3/2(N−1)), 0) 的复杂性，其中 std::max_element 和 std::min_element 分别是 max(N-1,0)，因此使用 std::minmax_element 的操作减少了大约 25%

也有区别，std::minmax_element 找到最后一个最大的元素，而std::max_element 找到第一个最大的元素。

因此，如果您需要查找范围的最小值和最大值，则应使用std::minmax_element。如果您只需要最小值或最大值，那么您应该使用专用版本。使用即将到来的 C++17 标准和结构化绑定，处理来自 std::minmax_element 的返回将变得更加容易。你会写的

auto [min, max] = std::minmax_element(...);

现在该对的第一个元素存储在min 中，第二个元素存储在max 中。

Answer 2

其他答案都很好。我想补充一点关于minmax_element 必须如何工作的内容，但这也有助于解释为什么它（通常）比单独运行min_element 和max_element 工作得更好，并讨论它的一些具体情况没有表现更好。

如果我们考虑一个简单的实现，您将维护一个最大值和最小值（以及它们相应的迭代器）并简单地遍历范围，将每个值与最小值和最大值进行比较并调整根据需要。但是，这会给您总共 2N 次比较；虽然它可能比遍历列表两次（由于更好地使用局部性）表现得更好，但规范要求（大约）3/2 N 比较。那怎么可能呢？

它通过处理对而不是单个项目来工作。取范围内的前两项（#0 和#1），我们可以比较它们并将最大值分配给最大值，将最小值分配给最小值。然后，我们比较接下来的两项（#3 和#4）来决定哪一项更大；我们将较大的一个与最大值进行比较，将较小的一个与最小值进行比较，并根据需要更新最大值/最小值。然后，我们对每一对额外的对（#5 和 #6，然后是 #7 和 #8，依此类推）重复此过程。

因此，每对都需要进行 3 次比较 - 相互比较，然后是当前最大值的最高值，以及当前最小值的最低值。这将所需的比较次数减少到 3/2 N！

然而，根据下面的 cmets，应该注意的是，当使用比较便宜的类型（或比较器）时，这种“改进的”算法在现代处理器上往往会产生比原始版本更差的性能 - 特别是，范围超过vector<int> 或类似：每对的两个元素之间的比较具有不可预测的结果，导致处理器中的分支预测失败（尽管这仅在数据或多或少随机排序时才成立）；当前的编译器并不总是将分支转换为条件传输，因为它们可能会这样做。此外，编译器更难向量化更复杂的算法。

理论上，我认为，C++ 库实现可以为 minmax_element 函数提供重载，该函数使用默认比较器的原始（int 等）元素类型的朴素算法。虽然标准要求对比较次数进行限制，但如果无法观察到这些比较的效果，那么实际计算的数字并不重要，只要时间复杂度相同（在这两种情况下都是 O(N)） .但是，虽然这可能会为随机排序的数据提供更好的性能，但在数据排序时可能会产生更差的性能。

考虑到以上所有因素，一个简单的测试用例（如下）显示了一个有趣的结果：对于随机排序的数据，分别使用min_element 和max_element 实际上可以稍微快一点使用minmax_element。 但是，对于已排序的数据，minmax_element 比单独使用 min_element 和 max_element 快得多。在我的系统（Haswell 处理器）上（使用gcc -O3 -std=c++11 -march=native，GCC 版本 5.4 编译），示例运行分别显示 min/max 为 692 毫秒，minmax 组合为 848 毫秒。当然，运行之间存在一些差异，但这些值似乎很典型。

注意：

• 性能差异很小，不太可能成为实际程序中的主导因素；
• 差异取决于编译器优化；未来，结果很可能会逆转；
• 对于更复杂的数据类型（或者更确切地说是更复杂的比较器），结果可能会相反，因为在这种情况下，较少的比较可能会带来显着的改进。
• 当样本数据是有序的而不是随机的（在下面的程序中将 v.push_back(r(gen)) 替换为 v.push_back(i)）时，性能非常不同：对于单独的 min/max，大约为 728 毫秒，而对于组合的 minmax，它会下降到 246 毫秒。

代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
#include <chrono>

constexpr int numEls = 100000000;

void recresult(std::vector<int> *v, int min, int max)
{
   // Make sure the compiler doesn't optimize out the values: 
   __asm__ volatile (
       ""
       :
       : "rm"(v), "rm"(min), "rm"(max)
   );
}

int main(int argc, char **argv)
{
    using namespace std;

    std::mt19937 gen(0);
    uniform_int_distribution<> r(0, 100000);


    vector<int> v;
    for (int i = 0; i < numEls; i++) {
        v.push_back(r(gen));
    }

    // run once for warmup
    int min = *min_element(v.begin(), v.end());
    int max = *max_element(v.begin(), v.end());
    recresult(&v, min, max);

    // min/max separately:
    {
        auto starttime = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < 5; i++) {
        int min = *min_element(v.begin(), v.end());
            int max = *max_element(v.begin(), v.end());
            recresult(&v, min, max);
        }
        auto endtime = std::chrono::high_resolution_clock::now();
        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(endtime - starttime).count();

        cout << "min/max element: " << millis << " milliseconds." << endl;
    }

    // run once for warmup
    auto minmaxi = minmax_element(v.begin(), v.end());
    recresult(&v, *(minmaxi.first), *(minmaxi.second));

    // minmax together:
    {
        auto starttime = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < 5; i++) {
        minmaxi = minmax_element(v.begin(), v.end());
        recresult(&v, *(minmaxi.first), *(minmaxi.second));
        }
        auto endtime = std::chrono::high_resolution_clock::now();
        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(endtime - starttime).count();

        cout << "minmax element: " << millis << " milliseconds." << endl;
    }

    return 0;
}

Answer 3

是的。您只对范围进行一次迭代，而不是两次。

Answer 4

std::minmax_element 复杂度：

最多 max(floor(3/2(N−1)), 0) 次应用谓词，其中 N = std::distance(first, last)。

std::min_element 复杂度（与max_element 相同）：

恰好是 max(N-1,0) 次比较，其中 N = std::distance(first, last)。

忽略max和floor，我们得到：

(N-1) * 2 vs 3/2 (N-1)

因此，通过使用minmax_element，您将获得3/4 所需的比较，而使用max_element + min_element 或更好。

minmax_element 使用< 运算符的传递性，它知道如果它正在更新最小值，它不需要通过一次比较两个元素来比较最大值，即如果a < b 那么我们只需要检查min(a, current_min) 和max(b, current_max)，反之亦然。

另外值得注意的是：

这个算法不同于std::make_pair(std::min_element(), std::max_element())，不仅在效率上，还在于这个算法找到最后一个最大的元素而std::max_element找到第一个最大的元素。