C++ c++；向量双边排序

我有一个包含字符串和整数（count）对的向量，我根据count对所有内容进行排序，但是如果列表中有2个或更多重复，我还必须对字符串进行排序。比如,

3审判 2美味 2 abc

因此，列表中有2个，因此abc必须排在yummy之前。我的代码如下所示：

vector<pair<string, int> > values(hash_table.begin(), hash_table.end());

sort(values.begin(), values.end(), sort_reverse);


bool sort_reverse(const pair<string, int> &a, const pair<string, int> &b) {
  return a.second > b.second;
}

向量值（hash_table.begin（）、hash_table.end（））；
排序（values.begin（）、values.end（）、sort\u reverse）；
布尔排序_反向（常数对&a、常数对&b）{
返回a.second>b.second；
}

您可以使用大于比较而不是默认小于比较来反转任何范围的排序：

std::sort(values.begin(), values.end(), std::greater<std::pair<string, int>>());

编辑如果要更改比较标准，以按字典顺序将配对的

第二个

第一个和

第一个

第二个进行比较，则可以提供自己的比较功能。它仍然必须满足上述示例中的要求。使用

std:：tie

:

#include <tuple>

template<typename T1, typename T2>
struct pair_backwards_greater
{
  bool operator()(const std::pair<T1, T2>& lhs, const std::pair<T1, T2>& rhs) const
  {
    return std::tie(lhs.second, lhs.first) > std::tie(rhs.second, rhs.first);
  }
};

#包括
模板
结构对\u向后\u更大
{
布尔运算符（）（常数std:：pair&lhs，常数std:：pair&rhs）常数
{
返回标准：：tie（左秒，左秒第一）>标准：：tie（右秒，右秒第一）；
}
};

然后

排序（values.begin（），values.end（），pair_backwards_greater（））； 您还可以选择使用简单的lambda表达式，而不是手动编写函子：

  std::sort(values.begin(), values.end(),
            [](const std::pair<std::string, int> &lhs, const std::pair<std::string, int> &rhs) 
            {
              return std::tie(lhs.second, lhs.first) > std::tie(rhs.second, rhs.first); 
            }  
           );

排序（values.begin（），values.end（）， []（常数std:：pair&lhs，常数std:：pair&rhs） { 返回标准：：tie（左秒，左秒第一）>标准：：tie（右秒，右秒第一）； } );

---

std:：tie

需要C++11库支持，但在

boost:：tie

和

std:：tr1:：tie

中有C++03替代实现。Lambda表达式需要C++11语言支持。

您必须考虑这些值本身

bool sort_reverse(const pair<string, int> &a, const pair<string, int> &b) {
    return (a.second > b.second) || ((a.second == b.second) && (a.first > b.first));
}

bool排序\u反向（常数对&a，常数对&b）{
返回（a.second>b.second）| |（（a.second==b.second）和&（a.first>b.first））；
}

要在一次点击中对两个字段进行排序：

bool sort_pair(const std::pair<std::string, int> &a, const std::pair<std::string, int> &b) 
{
    return (a.second > b.second) ||  
        ( 
            (a.second == b.second)  &&
            (a.first > b.first)
    );
}

void sortVector(std::vector<std::pair<std::string, int> >& values)
{
    std::sort(values.begin(), values.end(), sort_pair);
}

bool排序对（const std:：pair&a，const std:：pair&b）
{
返回（a秒>b秒）|
( 
（a.second==b.second）&&
（a.优先>b.优先）
);
}
void sortVector（标准：：向量和值）
{
std:：sort（values.begin（）、values.end（）、sort\u对）；
}

---

另请参见条目

我想提出一个稍有不同的替代方案，并介绍了

稳定排序

的好处

typedef std::pair<int, std::string> CNP;

bool byName(CNP const& left, CNP const& right) { return left.second < right.second; }
bool byCount(CNP const& left, CNP const& right) { return left.first < right.first; }

std::sort(values.begin(), values.end(), byName);

std::stable_sort(values.begin(), values.end(), byCount);

---

注意：C++11有一个

is_sorted

方法，虽然它是用迭代器表示的，当然不是容器。

+1或

rbegin（）

和

rend（）

只是为了看看分级员是否注意到了。对不起，我不明白你的意思。实际上，我是根据元素的计数来排序的。如果有两个或更多的元素具有相同的计数，我只想对字符串进行排序。所以，在这种情况下，你的解决方案并不能真正解决我的问题。@Jason“他们的数量”是多少？据我所知，这解决了问题。所以有2对。对1->“测试”有计数2，对2->“asd”有计数2。首先，我是根据它们的计数来比较它们的，但是现在我必须根据它们的计数和字母顺序来比较它们。@Jason啊，好的，那么你想通过第一个

int

和第二个

字符串来比较它们吗？我将编辑我的答案。为什么这是错误的？他正在搜索一个排序，比如1:“3 trail”2:“2 abc”（2条进入原因领先'a'）3:“2 yummy”（3条进入原因领先'y'）再次感谢您的投票；）我真的不知道为什么被否决了。。。无注释：P@Jason:np，因为它不满足严格弱排序，这是排序算法的要求。这是技术上未定义的行为。这不起作用；正如@juanchopanza所说，在某些数据上，这将完全失败。你能举个例子吗。我不知道这会在哪里失败？它是大还是不大。。。如果第二个不是更大，那么它就是假的，如果第二个更大，它取决于第一个，哪个可能更大，哪个可能不大……是的，我只是在寻找这个：D@P0W确切地实际上，一对的排序是规范的，只有在正常情况下，主排序基于
第一次
，而不是
第二次
。这是一个非常有用的建议。顺便说一句，值得一提的是，在C++11中有一个
std:：is_sorted
。@juanchopanza:噢！我不知道！
bool sort_pair(const std::pair<std::string, int> &a, const std::pair<std::string, int> &b) 
{
    return (a.second > b.second) ||  
        ( 
            (a.second == b.second)  &&
            (a.first > b.first)
    );
}

void sortVector(std::vector<std::pair<std::string, int> >& values)
{
    std::sort(values.begin(), values.end(), sort_pair);
}

typedef std::pair<int, std::string> CNP;

bool byName(CNP const& left, CNP const& right) { return left.second < right.second; }
bool byCount(CNP const& left, CNP const& right) { return left.first < right.first; }

std::sort(values.begin(), values.end(), byName);

std::stable_sort(values.begin(), values.end(), byCount);

template <typename C, typename P>
bool is_sorted(C const& list, P comp) {
    typedef typename C::const_reference CR;

    auto const reversed = [](CR left, CR right) { return comp(right, left);  };

    return std::adjacent_find(list.begin(), list.end(), reversed) == list.end();
}