c++ - 使用内置函数(或任何其他方法)在 C++ 中对二维数组进行排序？

Question

我有一个二维数组，如下所示。 (数组[5][2])

20  11    
10  20
39  14
29  15
22  23

排序后应该是这样的。

10  20
20  11
22  23
29  15
39  14

这意味着数组应该只比较第一列的值进行排序。

在 Java 中有一个内置函数可以做到这一点。如下所示。

Arrays.sort(a, new Comparator<Long[]>() {

            @Override
            public int compare(Long[] o1, Long[] o2) {

                Long t1 = o1[1];
                Long p1 = o1[0];
                Long t2 = o2[1];
                Long p2 = o2[0];

                if (t1 == t2) {
                    return (p1 > p2 ? 1 : (p1 == p2 ? 0 : -1));
                } else {
                    return (t1 < t2 ? -1 : 1);
                }

            }
        });

那么是否有任何 C++ 内置函数可以执行这些操作，或者我如何在 C++ 中执行此操作(最快的实现)？

提前致谢:)

Answer 1

我提供它只是因为它是 std::qsort 做得很好的少数事情之一 std::sort根本就不会，即对多列固定数组进行排序:比较器是一串三元语句，但看久了应该就够清楚了:

#include <iostream>
#include <random>
#include <algorithm>

int main()
{
    int ar[10][2];

    // populate with random data
    std::random_device rd;
    std::default_random_engine rng(rd());
    std::uniform_int_distribution<> dist(1,20);
    std::for_each(std::begin(ar), std::end(ar),
        [&](int (&ar)[2]){ ar[0] = dist(rng); ar[1] = dist(rng); });

    std::cout << "Before Sort..." << '\n';
    std::for_each(std::begin(ar), std::end(ar),
        [](const int(&ar)[2]) { std::cout << ar[0] << ',' << ar[1] << '\n';});

    std::qsort(ar, 10, sizeof(*ar),
        [](const void *arg1, const void *arg2)->int
        {
            int const *lhs = static_cast<int const*>(arg1);
            int const *rhs = static_cast<int const*>(arg2);
            return (lhs[0] < rhs[0]) ? -1
                :  ((rhs[0] < lhs[0]) ? 1
                :  (lhs[1] < rhs[1] ? -1
                :  ((rhs[1] < lhs[1] ? 1 : 0))));
        });

    std::cout << "After Sort..." << '\n';
    std::for_each(std::begin(ar), std::end(ar),
        [](const int(&ar)[2]) { std::cout << ar[0] << ',' << ar[1] << '\n';});

    return 0;
}

sample 运行(显然，您的会有所不同)

Before Sort...
2,11
18,4
20,20
14,6
8,10
17,8
14,14
3,10
20,14
19,19
After Sort...
2,11
3,10
8,10
14,6
14,14
17,8
18,4
19,19
20,14
20,20

注意:这特别使用严格值比较而不是比较器中的减法快捷方式，以避免潜在的下溢问题。如果这在您的受限数据空间中不是问题，您可以轻松地使该比较器显着简化。