Sort Vector of Pairs in Ascending Order in C++

Try it on GfG Practice

Sorting a vector of pairs in ascending order means arranging the elements in such a way that first pair is lesser than second pair, second pair is lesser than third pair and so on.

The easiest way to sort the vector of pairs in ascending order is to use std::sort() function. The below code example illustrates this method:

#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<pair<int, char>> v = {{5, 'a'},
                      {1, 'c'}, {2, 'b'}};

    // Sort above vector v
    sort(v.begin(), v.end());

    for (auto i : v)
        cout << i.first << ": " << i.second
      		<< endl;
    return 0;
}

1: c
2: b
5: a

Explanation: By default, sort() function sorts the vector of pairs in the ascending order of the first member of pairs. If the first members are equal, then it compares the second members.

There are also other methods available in C++ to sort the vector of pairs in ascending order. Let's look at each of them one by one.

Using sort() with Custom Comparison

To change the way of comparison, such as sorting on the basis of the second member of pairs, a custom comparator function that redefines the rules for comparing two pairs is used with sort().

#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<pair<int, char>> v = {{5, 'a'},
                      {1, 'c'}, {2, 'b'}};
  
  	// Comparator that compares two pairs'
  	// second members
  	auto comp = [](pair<int, int> a, pair
                   <int,int> b) {
      	return a.second < b.second;
    };

    // Sort the vector of pairs
    sort(v.begin(), v.end(), comp);

    for (auto i : v)
        cout << i.first << ": " << i.second
      		<< endl;
    return 0;
}

5: a
2: b
1: c

Explanation: The comp lambda expression compares the second member of two pairs a and b and return true if the a.second is smaller than b.second. This function is passed to sort() as a parameter.

Using stable_sort()

The std::stable_sort() function is another sorting function available in C++ that can be used to sort the vector of pairs in ascending order just like sort() function.

#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<pair<int, char>> v = {{5, 'a'},
                      {1, 'c'}, {2, 'b'}};

    // Sort the vector of pairs
    stable_sort(v.begin(), v.end());

    for (auto i : v)
        cout << i.first << ": " << i.second << endl;
    return 0;
}

1: c
2: b
5: a

The stable_sort() function maintains the relative order of elements with equal keys which can be useful when you want to preserve the original order for equal elements.

Using Multiset

Elements in multiset container are stored in ascending order by default. So, we can create a std::multiset of pairs from the vector of pairs and then copy all the elements back to the vector to get it sorted.

#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<pair<int, char>> v = {{5, 'a'}, 
                      {1, 'c'}, {2, 'b'}};

    // Create the multiset with vector
    multiset<pair<int, char>> ms(v.begin(),
                                 v.end());
    
    // Copy all elements of multiset
  	// back to vector
  	v.clear();
    copy(ms.begin(), ms.end(), back_inserter(v));
    
    for (auto i : v)
        cout << i.first << ": " << i.second
      		<< endl;
    return 0;
}

1: c
2: b
5: a

This method is not generally used as the above methods already work for almost every scenario. It is just mentioned here for informational purpose.