Question

我正在尝试以(i,j)然后if (i.first > j.first)首先出现，i然后if (i.first == j.first)更少的方式对i.second对数组进行排序比j.second要优先，这是我编写的函数，但似乎不起作用

#include <stdio.h>
#include <utility>
#include <algorithm>

using namespace std;

bool cmp(pair<int,int> i, pair<int,int> j) {
    if(i.first > j.first)
        return i<j;
    else if (i.first == j.first) {
        if(i.second > j.second)
            return i < j;
        else
            return j<i;
    }
    else
        return j<i;
}

int main(int argc, char **argv)
{
    pair<int,int> arr[4];
    arr[0]=make_pair<int,int>(3,7);
    arr[1]=make_pair<int,int>(2,5);
    arr[2]=make_pair<int,int>(3,4);
    arr[3]=make_pair<int,int>(1,8);
    sort(arr,arr+3,cmp);
    for (int i=0;i<4;i++)
    {
        printf("element (%d,%d)\n",get<0>(arr[i]),get<1>(arr[i]));
    }
}

排序功能似乎无效：

$ g++ -o main main.cpp
$ ./main
element (3,7)
element (2,5)
element (3,4)
element (1,8)

有什么想法吗？感谢您阅读

Answer 1

这应该有效：

bool cmp(pair<int,int> i, pair<int,int> j)
{
    if( i.first == j.first ) 
        return i.second < j.second;
    return i.first > j.first;
}

Answer 2

您可能依赖于对/元组的默认顺序，因此请调整输入：

bool cmp(pair<int,int> lhs, pair<int,int> rhs) {
    return std::make_pair(-lhs.first, lhs.second)
         < std::make_pair(-rhs.first, rhs.second);
}

或

bool cmp(pair<int,int> lhs, pair<int,int> rhs) {
    return std::tie(rhs.first, lhs.second)
         < std::tie(lhs.first, rhs.second);
}

Answer 3

bool cmp(std::pair<int, int> i, std::pair<int, int> j)
{
    if(i.first > j.first)
    {
        // now i IS greater than j, so just:
        return true;
    }

    // you returned, so you can only get here if the condition was not met;
    // some consider still using else bad style...

    else if (i.first == j.first)
    {
        // don't ever use if(condition) return true; else return false;
        // just do:       return condition;
        // so:
        return i.second > j.second;
    }
    else
    {
        return false;
    }
}

您可以将其短一点：

bool greater(std::pair<int, int> i, std::pair<int, int> j)
{
    if(i.first == j.first)
    {
        return i.second < j.second;
    }
    return i.first > j.first;
}

甚至是单线：

return i.first == j.first ? i.second < j.second : i.first > j.first;

最后，您也可以使用lambda（如果仅在一个位置按此特定顺序排序）：

std::sort
(
    a, a + n,
    [](std::pair<int,int> i, std::pair<int,int> j)
    {
        return i.first == j.first ? i.second < j.second : i.first > j.first;
    }
);

最后解释您的原始代码：

if(i.first > j.first)
    // std::pair's comparison operator will exactly do the analog
    // stuff you INTENDED to do, but now, as the "first"s already
    // compare greater, i < j will return just the opposite,
    // i. e. false(!!!)
    return i < j;

类似地，所有其他比较，所以您等于：

bool cmp(std::pair<int, int>, std::pair<int, int>)
{
    return false;
}

根据比较函数C ++对对数组进行排序

3 个答案: