Skip to content
Related Articles

Related Articles

stable_sort() in C++ STL

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 23 Dec, 2021
Improve Article
Save Article

stable_sort() is used to sort the elements in the range [first, last) in ascending order. It is like std::sort, but stable_sort() keeps the relative order of elements with equivalent values. It comes under the <algorithm> header file.

Syntax:

template< class RandomIterator>
void stable_sort( RandomIterator first, RandomIterator last );

or

template< class RandomIterator, class Compare>
void stable_sort( RandomIterator first, RandomIterator last, Compare comp );

Parameters:

  • first:  iterator pointing to the first element in the range.
  • last:  iterator pointing to the past last element in the range.
  • comp: predicate function that accepts two arguments and returns true if the two arguments are in order and false otherwise.

Return Value: It returns nothing.

Example:

CPP




// C++ program to demonstrate stable sort() in STL
#include <bits/stdc++.h>
using namespace std;
 
// Driver Code
int main()
{
    int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    stable_sort(arr, arr + n);
 
    cout << "Array after sorting using "
            "stable_sort is : \n";
    for (int i = 0; i < n; ++i)
        cout << arr[i] << " ";
 
    return 0;
}

Output

Array after sorting using stable_sort is : 
0 1 2 3 4 5 6 7 8 9 

How to Sort in Descending Order using stable_sort()?

Like sort(), stable_sort() takes a third parameter that is used to specify the order in which elements are to be sorted. We can pass “greater()” function to sort in decreasing order. This function does comparison in a way that puts greater element before. 

Syntax:

// arr is the array and n is the size
stable_sort(arr, arr + n, greater<int>());  

Example:

CPP




// C++ program to demonstrate descending order
// stable sort using greater<>().
#include <bits/stdc++.h>
using namespace std;
 
// Driver Code
int main()
{
    int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    stable_sort(arr, arr + n, greater<int>());
 
    cout << "Array after sorting : \n";
    for (int i = 0; i < n; ++i)
        cout << arr[i] << " ";
 
    return 0;
}

Output

Array after sorting : 
9 8 7 6 5 4 3 2 1 0 

When to Prefer stable_sort over sort()? 

Sometime we want to make sure that order of equal elements is same in sorted array as it was in original array. This can be useful if these values have associated other fields. For example, 

  • Consider sorting students by marks, if two students have the same marks, we may want to keep them in the same order as they appear input. Please refer to stability in sorting algorithms for details.
  • Consider we have time intervals sorted by ending time and we want to sort by start time. Also, if two start times are same, we want to keep them sorted by the end time. This is not guaranteed by sort().

CPP




// A C++ program to demonstrate STL stable_sort()
// to sort intervals according to start time.
#include <bits/stdc++.h>
using namespace std;
 
// An interval has start time and end time
struct Interval {
    int start, end;
};
 
// Compares two intervals according to starting
// times.
bool compareInterval(Interval i1, Interval i2)
{
    return (i1.start < i2.start);
}
 
int main()
{
    // Given intervals are sorted according to end time
    Interval arr[]
        = { { 1, 3 }, { 2, 4 }, { 1, 7 }, { 2, 19 } };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // sort the intervals in increasing order of
    // start time such that the start time intervals
    // appear in same order as in input.
    stable_sort(arr, arr + n, compareInterval);
 
    cout << "Intervals sorted by start time : \n";
    for (int i = 0; i < n; i++)
        cout << "[" << arr[i].start << ", " << arr[i].end
             << "] ";
 
    return 0;
}

Output

Intervals sorted by start time : 
[1, 3] [1, 7] [2, 4] [2, 19] 

Difference Between sort and stable_sort()

Key

sort()

stable_sort()

Implementation sort() function usually uses Introsort. Therefore, sort() may preserve the physical order of semantically equivalent values but can’t be guaranteed. stable_sort() function usually uses mergesort. Therefore, stable_sort() preserve the physical order of semantically equivalent values and its guaranteed.
Time Complexity It is O(n*log(n))

It is O(n*log^2(n))

If additional memory linearly proportional to length is not available. If its available then O(n*log(n)).

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!