C++ Algorithm prev_permutation ()

C++ Algorithm prev_permutation() function is used to reorder the elements in the range [first, last) into the previous lexicographically ordered permutation.

A permutation is specified as each of several possible ways in which a set or number of things can be ordered or arranged. It is denoted as N! where N = number of elements in the range.

Elements are compared using operator < for the first version or using the given binary comparison function comp for the second version.

Syntax

default (1)   template <class BidirectionalIterator>
                       bool prev_permutation (BidirectionalIterator first,
                                                                           BidirectionalIterator last );

custom (2)   template <class BidirectionalIterator, class Compare>
                       bool prev_permutation (BidirectionalIterator first,
                                                       BidirectionalIterator last, Compare comp);

Parameter

first: A bidirectional iterator pointing to the first element in the range to be permuted.

last: A bidirectional iterator pointing the position one past the last in the range to be permuted.

comp: A user-defined binary predicate function that accepts two arguments and returns true if the two arguments are in order otherwise returns false. It follows the strict weak ordering to order the elements.

Return value

It returns true if the function could reorder the object as a lexicographically smaller permutations.

Else, the function returns false to indicate that the arrangement is not less than the previous, but the largest possible (sorted in descending order).

Complexity

Complexity is up to linear in half the distance between first and last.

Data Races

The object in the range [first, last) are modified.

Exceptions

This function throws an exception if either element swap or an operation on iterators throws an exception.

Note: Invalid parameters cause an undefined behavior.

Example 1

Let's see a simple example to demonstrate the use of prev_permutation():

#include <algorithm>
#include <string>
#include <iostream>
#include <functional>

using namespace std;

int main()
{
    string s="abc";
    sort(s.begin(), s.end(), greater<char>());
    do {
        cout << s << ' ';
    } while(prev_permutation(s.begin(), s.end()));
    cout << '\n';
    
    return 0;
}

Output:

cba cab bca bac acb abc

Example 2

Let's see another simple example:

#include <iostream>     // std::cout
#include <algorithm>    // std::next_permutation, std::sort, std::reverse

using namespace std;

int main () {
  int myints[] = {1,2,3};

  sort (myints,myints+3);
  reverse (myints,myints+3);

  cout << "The 3! possible permutations with 3 elements:\n";
  do {
    cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';
  } while ( prev_permutation(myints,myints+3) );

  cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';

  return 0;
}

Output:

The 3! possible permutations with 3 elements:
3 2 1
3 1 2
2 3 1
2 1 3
1 3 2
1 2 3
After loop: 3 2 1

Example 3

Let's see another simple example to demonstrate the use of prev_permutation using default version:

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

int main()
{
    string s;

    cout << "Enter the String : ";
    cin >> s;
    sort(s.rbegin(), s.rend());
    cout << "Permutations of " << s << endl;
    do
    {
        cout << s << "\t";
    }
    while (prev_permutation(s.begin(), s.end()));
    return 0;
}

Output:

Enter the String : NIK
Permutations of NKI
NKI	NIK	KNI	KIN	INK	IKN

Example 4

Let's see a simple example demonstrate the use of prev_permutation() using comparison function:

#include <iostream>
#include <algorithm>
using namespace std;
// Function to rearrange the specified string as lexicographically smaller
// permutation. It returns false if the string cannot be rearranged as
// lexicographically smaller permutation, else it returns true
bool prevPermutation(string &s, int n)
{
    // Find largest index i such that s[i-1] is more than s[i]
    int i = n-1;
    while (i > 0 && s[i-1] <= s[i])
    {
        // Return false if i is at first index of the string
        // This means we're already at lowest possible permutation
        if (--i == 0)
            return false;
    }

    // s[i..n-1] is now sorted in natural order

    // Find highest index j such that j >= i and s[j] < s[i-1]
    int j = i;
    while (j < n && s[j] <= s[i-1])
        j++;

    j--;

    // Swap characters at index i-1 with index j
    swap(s[i-1], s[j]);

    // Reverse the substring s[i..n-1] and return true
    reverse (s.begin() + i, s.end());

    return true;
}

// Program to find lexicographically smaller permutations of a string
int main()
{
    string s = "231";

    // std::sort(rbegin(s), rend(s));

    // find all lexicographically smaller permutations using
    // std::prev_permutation
    while (1)
    {
        // print current permutation
        cout << s << " ";

        // find previous permutation in lexicographic order
        if (!prevPermutation(s, s.length()))
            break;
    }

    return 0;
}

Output: