Jak sortować wektor par na podstawie drugiego elementu pary?

Question

Jeśli mam wektor par:

std::vector<std::pair<int, int> > vec; 

istnieje i łatwy sposób sortowania listy rosnące w oparciu o drugi element pary?

wiem, że mogę napisać trochę obiektu funkcji, które będą wykonywać pracę, ale czy jest jakiś sposób, aby wykorzystać istniejące części STL i std::less zrobić bezpośrednio pracę?

EDYCJA: Rozumiem, że mogę napisać oddzielną funkcję lub klasę, aby przejść do trzeciego argumentu do sortowania. Pytanie brzmi, czy mogę zbudować go z standardowych rzeczy. Ja naprawdę coś, co wygląda jak:

std::sort(vec.begin(), vec.end(), std::something_magic<int, int, std::less>()); 

Answer 1

Można użyć impuls tak:

std::sort(a.begin(), a.end(), 
      boost::bind(&std::pair<int, int>::second, _1) < 
      boost::bind(&std::pair<int, int>::second, _2)); 

nie wiem standardowy sposób robienia tego równie krótko i zwięźle, ale można pobrać boost::bind to wszystko składa się z nagłówków.

Answer 2

Trzeba polegać na braku standardu select2nd

Answer 3

EDIT: przy użyciu C++ 14, najlepszym rozwiązaniem jest bardzo łatwe do napisania dzięki do lambd, które mogą teraz mieć parametry typu auto. To jest moje obecne rozwiązanie ulubiony

std::sort(v.begin(), v.end(), [](auto &left, auto &right) { 
    return left.second < right.second; 
}); 

---

Wystarczy użyć niestandardowego komparator (jest to opcja 3-ci argument std::sort)

struct sort_pred { 
    bool operator()(const std::pair<int,int> &left, const std::pair<int,int> &right) { 
     return left.second < right.second; 
    } 
}; 

std::sort(v.begin(), v.end(), sort_pred()); 

Jeśli używasz kompilatora C++ 11 , możesz napisać to samo, używając lambdas:

std::sort(v.begin(), v.end(), [](const std::pair<int,int> &left, const std::pair<int,int> &right) { 
    return left.second < right.second; 
}); 

EDIT: w odpowiedzi na Twoich zmian na swoje pytanie, oto kilka myśli ... jeśli naprawdę chce być kreatywny i móc ponownie wykorzystać tą koncepcją dużo, po prostu zrobić szablon:

template <class T1, class T2, class Pred = std::less<T2> > 
struct sort_pair_second { 
    bool operator()(const std::pair<T1,T2>&left, const std::pair<T1,T2>&right) { 
     Pred p; 
     return p(left.second, right.second); 
    } 
}; 

następnie można to zrobić też:

std::sort(v.begin(), v.end(), sort_pair_second<int, int>()); 

lub nawet

std::sort(v.begin(), v.end(), sort_pair_second<int, int, std::greater<int> >()); 

Choć szczerze mówiąc, to wszystko jest trochę przesada, wystarczy napisać funkcję linia 3 i być z nim zrobić :-P

Answer 4

Na coś wielokrotnego użytku:

template<template <typename> class P = std::less > 
struct compare_pair_second { 
    template<class T1, class T2> bool operator()(const std::pair<T1, T2>& left, const std::pair<T1, T2>& right) { 
     return P<T2>()(left.second, right.second); 
    } 
}; 

można go używać jako

std::sort(foo.begin(), foo.end(), compare_pair_second<>()); 

lub

std::sort(foo.begin(), foo.end(), compare_pair_second<std::less>()); 

Answer 5

z C++ 0x możemy wykorzystać funkcje lambda:

using namespace std; 
vector<pair<int, int>> v; 
     . 
     . 
sort(v.begin(), v.end(), 
    [](const pair<int, int>& lhs, const pair<int, int>& rhs) { 
      return lhs.second < rhs.second; }); 

W tym przykładzie zwracany typ bool jest domyślnie wydedukowany.

Lambda rodzaje powrotne

Gdy funkcja lambda ma pojedynczą instrukcję, a to jest zwrot oświadczenie, kompilator może wywnioskować typ zwracany. Od C++ 11, §5.1.2/4:

...

• Jeśli związek-deklaracja ma postać { return expression ; } typ zwracanej wypowiedzi po lwartość do RValue konwersja (4.1), konwersja tablicy do wskaźnika (4.2) i konwersja funkcji do wskaźnika (4.3);
• inaczej, void.

Aby jednoznacznie określić typ zwracanej skorzystać z formularza []() -> Type { }, jak w:

sort(v.begin(), v.end(), 
    [](const pair<int, int>& lhs, const pair<int, int>& rhs) -> bool { 
      if (lhs.second == 0) 
       return true; 
      return lhs.second < rhs.second; }); 

Answer 6

jest dość prosty użyć funkcji sortowania z algorytmu i dodać własne porównanie funkcji

vector< pair<int,int > > v; 
sort(v.begin(),v.end(),myComparison); 

Teraz musisz dokonać porównania na podstawie drugiej selekcji , tak aby zadeklarować "myComp" Arison”jako

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

Answer 7

Spróbuj zamiana elementów par, dzięki czemu można używać std::sort() jako normalne.