c++ 类双重排序（？）答案

【问题标题】：c++ class double sorting(?)c++ 类双重排序（？）
【发布时间】：2017-08-11 05:56:09
【问题描述】：

我想使用类双排序（？）编写代码。

例如，类有三个数据成员，即num、error和data。

class Test
{
public:
    int num;
    float error;
    vector<float> data;
};

现在，我做：

vector<Test> TestList;

而且，那些有：

TestList[0] : num = 1, error = 0.001, data0

TestList[1] : num = 1, error = 0.01, data1

TestList[2] : num = 2, error = 0.01, data2

TestList[3] : num = 3, error = 0.001, data3

TestList[4] : num = 3, error = 0.01, data4

然后，我想用num（更高优先级）和error对它们进行排序。
预期的结果是TestList 按以下顺序排列：

测试[4] : num = 3, error = 0.001, data4

Test[3] : num = 3, error = 0.01, data3

Test[2] : num = 2, error = 0.01, data2

Test[0] : num = 1, error = 0.001, data0

Test[1] : num = 1, error = 0.01, data1

我该怎么做？另外，这个算法怎么调用？

【问题讨论】：

查找记录为“稳定”排序的排序，然后首先按error 排序，然后按num 排序。例如mergesort 是一种稳定的排序算法。
What's the simplest way of defining lexicographic comparison for elements of a class?的可能重复

标签： c++ class sorting

【解决方案1】：

您所指的订单被称为 Lexicographical order

您可以通过提供合适的比较器或实现operator< 来简单地将vector<Test> 与std::sort 排序，如Sorting a vector of custom objects 中所述

最后的实现可能是这样的：

class Test
{
public:
    int num;
    float error;
    vector<float> data;
    bool operator<( const X& val ) const
    { 
      if (num > val.num)
      {
        return true;
      }
      else if (num == val.num && error < val.error)
      {
        return true;
      }
      else
      {
        return false;
      }
    }
}

【讨论】：

【解决方案2】：

在测试中实现运算符<

class Test {
public:
    int num;
    float error;
    vector<float> data;

    bool operator < (const Test & val)const
    { 
      return num > val.num || num == val.num && error < val.error; 
    }
};

使用std::sort进行排序

sort(TestList.begin(), TestList.end());

【讨论】：

我猜是一个小贴士：应该是num < val.num，更小而不是更大。
@AdrianMaire OP 希望 num 降序排序
您不能让比较运算符仅针对向量排序的单个案例表现错误/不直观：为什么如果再往前 20 行，您需要另一个排序但升序？使用反向迭代。
如果需要用其他方式排序，可以给std::sort提供另外一个比较函数。运算符

【解决方案3】：

std::sort 带有一个比较器，所以你可以使用：

std::vector<Test> tests /* = ...*/;

std::sort(tests.begin(), test.end(), [](const Test& lhs, const Test& rhs)
    {
        return std::tie(rhs.num, rhs.error) < std::tie(lhs.num, lhs.error);
    });

【讨论】：

【解决方案4】：

您可以使用std::sort，并提供比较函数对象。

auto NumDescErrorAsc = [](const Test & lhs, const Test & rhs)
{ return std::tie(rhs.num, lhs.error) < std::tie(lhs.num, rhs.error); };
auto NumAscErrorAsc = [](const Test & lhs, const Test & rhs)
{ return std::tie(lhs.num, lhs.error) < std::tie(rhs.num, rhs.error); };

sort(TestList.begin(), TestList.end(), NumDescErrorAsc); // Required order

sort(TestList.begin(), TestList.end(), NumAscErrorAsc); // Original order

之所以有效，是因为std::tuple::operator< 提供了基于第一个值的排序，而后面的值打破了关系。请注意我们如何在NumDescErrorAsc 中使用左侧的右侧数字。这相当于使用 > 表示 num。

【讨论】：