Stable sort vector alternating large and small values - c++11

Question

Given a vector of pair of int and string something like this vector<pair<int,string>> . I need to sort them in a different fashion.
I want first element to be largest. Second element to be smallest and so on. Also if values are same then values must be shown in order in which they appear in original list.
Like say we have something like this : N=5 and here are 5 pairs :
10 bcd
2 abc
30 def
2 xyz
50 mn
Then output array should be : [mn,abc,def,xyz,bcd]
Explanation : Firstly 50 is largest so first element is "mn" then 2 is minimum but as "abc" come above "xyz" so take "abc" first. Then again maximum is 30 so "def",then minimum is 2 with "xyz" and then remaining "bcd" at end.
How can this be done with C++11 STL ? I know its otherwise not so difficult

Answer 1

Here's an idea:
Stable sort your vector of elements based on their integers
Create a number of buckets for each unique value
Each bucket is stable-sorted for those values in original vector
Print out the buckets alternating elements from the largest-valued bucket and the smallest-valued bucket
Print the entire contents of a bucket before moving onto the next bucket.
So with your original list:
10 bcd
2 abc
30 def
2 xyz
50 mn
After stable sorting:
2 abc
2 xyz
10 bcd
30 def
50 mn
Create buckets:
2: (2, abc), (2,xyz)
10: (10, bcd)
30: (30, def)
50: (50, mn)
Print first element of bucket 50:
50, mn
Print first element of bucket 2:
2, abc
Print next element of bucket 50... doesn't exist, move onto next smallest bucket, 30.
Print next element of bucket 30:
30, def
Print next element of bucket 2:
2, xyz
No more elements in bucket 30, so move on to bucket 10:
10, bcd
No more elements in bucket 2, so move on to bucket 10. We have already reached bucket 10 from the other side, so stop here.
My implementation uses std::stable_sort and std::map, and doesn't completely follow this logic, but it works even in cases where all elements are the same:
Live Demo
Code:
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <string>
#include <map>
using namespace std;
void PrintPair(const std::pair<int, std::string>& thePair)
{
std::cout << thePair.first << ", " << thePair.second << std::endl;
}
int main() {
// create our vector
std::vector<std::pair<int, std::string>> myVector{
std::make_pair(10,"bcd"),
std::make_pair(2, "abc"),
std::make_pair(30, "def"),
std::make_pair(2, "xyz"),
std::make_pair(50, "mn")
};
// print vector before sorting
std::cout << "vector before sorting:\n";
for (auto&& nextPair : myVector)
{
std::cout << nextPair.first << ", " << nextPair.second << std::endl;
}
// sort it on the ints in the pairs
std::stable_sort(std::begin(myVector),std::end(myVector), [](const std::pair<int,std::string>& lhs, const std::pair<int,std::string>& rhs){return lhs.first < rhs.first;});
// print vector after sorting
std::cout << "\nvector after sorting\n";
for (auto&& nextPair : myVector)
{
std::cout << nextPair.first << ", " << nextPair.second << std::endl;
}
std::map<int, decltype(myVector)> myBuckets;
for (auto&& nextElement : myVector)
{
if (myBuckets.find(nextElement.first) == myBuckets.end())
myBuckets[nextElement.first] = decltype(myVector){nextElement};
else
myBuckets[nextElement.first].emplace_back(nextElement);
}
//needs at least a 2 element vector to work
cout << "\nFinal output:\n";
// create buckets for each value, internally each bucket is stable sorted
// the buckets are sorted on map value
// print out each element in a bucket before moving onto the next bucket
auto bucketsBegin = myBuckets.begin();
auto bucketsEnd = myBuckets.end();
--bucketsEnd;
auto nextEndElement = bucketsEnd->second.begin();
auto nextBeginElement = bucketsBegin->second.begin();
while(bucketsBegin != myBuckets.end() && bucketsBegin != bucketsEnd)
{
if (bucketsEnd != bucketsBegin)
{
PrintPair(*nextEndElement);
++nextEndElement;
if (nextEndElement == bucketsEnd->second.end())
{
bucketsEnd--;
nextEndElement = bucketsEnd->second.begin();
}
}
PrintPair(*nextBeginElement);
++nextBeginElement;
if (nextBeginElement == bucketsBegin->second.end())
{
bucketsBegin++;
if (bucketsBegin != myBuckets.end())
nextBeginElement = bucketsBegin->second.begin();
}
}
//print remainder
while(nextBeginElement != bucketsBegin->second.end())
{
PrintPair(*nextBeginElement);
++nextBeginElement;
}
return 0;
}
Output:
vector before sorting:
10, bcd
2, abc
30, def
2, xyz
50, mn
vector after sorting
2, abc
2, xyz
10, bcd
30, def
50, mn
Final output:
50, mn
2, abc
30, def
2, xyz
10, bcd
And when nearly all the the elements in the vector have the same value:
vector before sorting:
1, bcd
1, abc
1, def
1, xyz
2, mn
vector after sorting
1, bcd
1, abc
1, def
1, xyz
2, mn
Final output:
2, mn
1, bcd
1, abc
1, def
1, xyz