Print all permutations in sorted (lexicographic) order

12 Jul, 2022
Given a string, print all permutations of it in sorted order. For example, if the input string is “ABC”, then output should be “ABC, ACB, BAC, BCA, CAB, CBA”.
We have discussed a program to print all permutations in this post, but here we must print the permutations in increasing order.
Algorithm to print the permutations lexicographic-ally:Step 1. Sort the given string in non-decreasing order and print it. The first permutation is always the string sorted in non-decreasing order.Step 2. Start generating next higher permutation. Do it until next higher permutation is not possible. If we reach a permutation where all characters are sorted and in non-increasing order, then that permutation is the last permutation.
Steps to generate the next higher permutation: Step 1. Take the previously printed permutation and find the rightmost character in it, which is smaller than its next character. Let us call this character as ‘first character’.Step 2. Now find the ceiling of the ‘first character’. Ceiling is the smallest character on right of ‘first character’, which is greater than ‘first character’. Let us call the ceil character as ‘second character’.Step 3. Swap the two characters found in above 2 steps.Step 4. Sort the substring (in non-decreasing order) after the original index of ‘first character’.
Approach:
1. Let us consider the string “ABCDEF”. Let the previously printed permutation be “DCFEBA”. 
2. The next permutation in sorted order should be “DEABCF”. 
3. Let us understand above steps to find next permutation. The ‘first character’ will be ‘C’. The ‘second character’ will be ‘E’. After swapping these two, we get “DEFCBA”. 
4. The final step is to sort the substring after the character original index of ‘first character’. Finally, we get “DEABCF”. 
Following is the implementation of the algorithm.
C++
C
Java
Python3
C#
Javascript
// C++ Program to print all permutations// of a string in sorted order.#include <bits/stdc++.h>using namespace std; /* Following function is needed for library function qsort(). Referhttp://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ */int compare (const void *a, const void * b){ return ( *(char *)a - *(char *)b ); } // A utility function two swap two characters a and bvoid swap (char* a, char* b){    char t = *a;    *a = *b;    *b = t;} // This function finds the index of the smallest character// which is greater than 'first' and is present in str[l..h]int findCeil (char str[], char first, int l, int h){    // initialize index of ceiling element    int ceilIndex = l;     // Now iterate through rest of the elements and find    // the smallest character greater than 'first'    for (int i = l+1; i <= h; i++)    if (str[i] > first && str[i] < str[ceilIndex])            ceilIndex = i;     return ceilIndex;} // Print all permutations of str in sorted ordervoid sortedPermutations ( char str[] ){    // Get size of string    int size = strlen(str);     // Sort the string in increasing order    qsort( str, size, sizeof( str[0] ), compare );     // Print permutations one by one    bool isFinished = false;    while ( ! isFinished )    {        // print this permutation        cout << str << endl;         // Find the rightmost character which is        // smaller than its next character.        // Let us call it 'first char'        int i;        for ( i = size - 2; i >= 0; --i )        if (str[i] < str[i+1])            break;         // If there is no such character, all are        // sorted in decreasing order, means we        // just printed the last permutation and we are done.        if ( i == -1 )            isFinished = true;        else        {            // Find the ceil of 'first char' in            // right of first character.            // Ceil of a character is the smallest            // character greater than it            int ceilIndex = findCeil( str, str[i], i + 1, size - 1 );             // Swap first and second characters            swap( &str[i], &str[ceilIndex] );             // Sort the string on right of 'first char'            qsort( str + i + 1, size - i - 1, sizeof(str[0]), compare );        }    }} // Driver program to test above functionint main(){    char str[] = "ABCD";    sortedPermutations( str );    return 0;} // This is code is contributed by rathbhupendra
// Program to print all permutations of a string in sorted order.#include <stdio.h>#include <stdlib.h>#include <string.h> /* Following function is needed for library function qsort(). Referhttp://www.cplusplus.com/reference/clibrary/cstdlib/qsort/ */int compare (const void *a, const void * b){ return ( *(char *)a - *(char *)b ); } // A utility function two swap two characters a and bvoid swap (char* a, char* b){    char t = *a;    *a = *b;    *b = t;} // This function finds the index of the smallest character// which is greater than 'first' and is present in str[l..h]int findCeil (char str[], char first, int l, int h){    // initialize index of ceiling element    int ceilIndex = l;     // Now iterate through rest of the elements and find    // the smallest character greater than 'first'    for (int i = l+1; i <= h; i++)    if (str[i] > first && str[i] < str[ceilIndex])            ceilIndex = i;     return ceilIndex;} // Print all permutations of str in sorted ordervoid sortedPermutations ( char str[] ){    // Get size of string    int size = strlen(str);     // Sort the string in increasing order    qsort( str, size, sizeof( str[0] ), compare );     // Print permutations one by one    bool isFinished = false;    while ( ! isFinished )    {        // print this permutation        printf ("%s \n", str);         // Find the rightmost character which is smaller than its next        // character. Let us call it 'first char'        int i;        for ( i = size - 2; i >= 0; --i )        if (str[i] < str[i+1])            break;         // If there is no such character, all are sorted in decreasing order,        // means we just printed the last permutation and we are done.        if ( i == -1 )            isFinished = true;        else        {            // Find the ceil of 'first char' in right of first character.            // Ceil of a character is the smallest character greater than it            int ceilIndex = findCeil( str, str[i], i + 1, size - 1 );             // Swap first and second characters            swap( &str[i], &str[ceilIndex] );             // Sort the string on right of 'first char'            qsort( str + i + 1, size - i - 1, sizeof(str[0]), compare );        }    }} // Driver program to test above functionint main(){    char str[] = "ABCD";    sortedPermutations( str );    return 0;}
// Java Program to print all permutations// of a string in sorted order. import java.util.*; class GFG{   // This function finds the index of the smallest  // character which is greater than 'first' and is  // present in str[l..h]  static int findCeil(char[] str, char first, int l,                      int h)  {    // initialize index of ceiling element    int ceilIndex = l;     // Now iterate through rest of the elements and find    // the smallest character greater than 'first'    for (int i = l + 1; i <= h; i++)      if (str[i] > first && str[i] < str[ceilIndex])        ceilIndex = i;     return ceilIndex;  }   // Print all permutations of str in sorted order  static void sortedPermutations(char[] str)  {    // Get size of string    int size = str.length;     // Sort the string in increasing order    Arrays.sort(str);     // Print permutations one by one    boolean isFinished = false;    while (!isFinished) {      // print this permutation      System.out.println(String.valueOf(str));       // Find the rightmost character which is      // smaller than its next character.      // Let us call it 'first char'      int i;      for (i = size - 2; i >= 0; --i)        if (str[i] < str[i + 1])          break;       // If there is no such character, all are      // sorted in decreasing order, means we      // just printed the last permutation and we are      // done.      if (i == -1)        isFinished = true;      else {        // Find the ceil of 'first char' in        // right of first character.        // Ceil of a character is the smallest        // character greater than it        int ceilIndex = findCeil(str, str[i], i + 1,                                 size - 1);         // Swap first and second characters        char temp = str[i];        str[i] = str[ceilIndex];        str[ceilIndex] = temp;         // Sort the string on right of 'first char'        Arrays.sort(str, i + 1, size);      }    }  }   // Driver program to test above function  public static void main(String[] args)  {    char[] str = { 'A', 'B', 'C', 'D' };    sortedPermutations(str);  }} // This is code is contributed by phasing17
# Python3 Program to print all permutations# of a string in sorted order. # The following function is needed for the sort method  # This function finds the index of the smallest character# which is greater than 'first' and is present in str[l..h]def findCeil(str_, first, l, h):     # initialize index of ceiling element    ceilIndex = l     # Now iterate through rest of the elements and find    # the smallest character greater than 'first'    for i in range(l + 1, h + 1):        if (str_[i] > first and str_[i] < str_[ceilIndex]):            ceilIndex = i     return ceilIndex  # Print all permutations of str in sorted orderdef sortedPermutations(str_):     # Get size of string    size = len(str_)     # Sort the string in increasing order    str_ = sorted(str_)     # Print permutations one by one    isFinished = False    while (isFinished is False):         # print this permutation        print("".join(str_))         # Find the rightmost character which is        # smaller than its next character.        # Let us call it 'first char'        i = size - 2        while i >= 0:            if (str_[i] < str_[i+1]):                break            i -= 1         # If there is no such character, all are        # sorted in decreasing order, means we        # just printed the last permutation and we are done.        if (i == -1):            isFinished = True        else:             # Find the ceil of 'first char' in            # right of first character.            # Ceil of a character is the smallest            # character greater than it            ceilIndex = findCeil(str_, str_[i], i + 1, size - 1)             # Swap first and second characters            temp = str_[i]            str_[i] = str_[ceilIndex]            str_[ceilIndex] = temp             # Sort the string on right of 'first char'            str_ = str_[:i + 1] + sorted(str_[i + 1:])  # Driver program to test above functionstr_ = "ABCD"sortedPermutations(str_) # This code is contributed by phasing17
// C# Program to print all permutations// of a string in sorted order. using System;using System.Collections.Generic; class GFG {    // This function finds the index of the smallest    // character which is greater than 'first' and is    // present in str[l..h]    static int findCeil(char[] str, char first, int l,                        int h)    {        // initialize index of ceiling element        int ceilIndex = l;         // Now iterate through rest of the elements and find        // the smallest character greater than 'first'        for (int i = l + 1; i <= h; i++)            if (str[i] > first && str[i] < str[ceilIndex])                ceilIndex = i;         return ceilIndex;    }     // Print all permutations of str in sorted order    static void sortedPermutations(char[] str)    {        // Get size of string        int size = str.Length;         // Sort the string in increasing order        Array.Sort(str);         // Print permutations one by one        bool isFinished = false;        while (!isFinished) {            // print this permutation            Console.WriteLine(new string(str));             // Find the rightmost character which is            // smaller than its next character.            // Let us call it 'first char'            int i;            for (i = size - 2; i >= 0; --i)                if (str[i] < str[i + 1])                    break;             // If there is no such character, all are            // sorted in decreasing order, means we            // just printed the last permutation and we are            // done.            if (i == -1)                isFinished = true;            else {                // Find the ceil of 'first char' in                // right of first character.                // Ceil of a character is the smallest                // character greater than it                int ceilIndex = findCeil(str, str[i], i + 1,                                         size - 1);                 // Swap first and second characters                char temp = str[i];                str[i] = str[ceilIndex];                str[ceilIndex] = temp;                 // Sort the string on right of 'first char'                Array.Sort(str, i + 1, size - i - 1);            }        }    }     // Driver program to test above function    public static void Main(string[] args)    {        char[] str = { 'A', 'B', 'C', 'D' };        sortedPermutations(str);    }} // This is code is contributed by phasing17
// JavaScript Program to print all permutations// of a string in sorted order. /* The following function is needed for the sort method */function compare (a, b){    return a.charCodeAt(0) - b.charCodeAt(0);} // This function finds the index of the smallest character// which is greater than 'first' and is present in str[l..h]function findCeil (str, first, l, h){    // initialize index of ceiling element    let ceilIndex = l;     // Now iterate through rest of the elements and find    // the smallest character greater than 'first'    for (let i = l+1; i <= h; i++)    if (str[i] > first && str[i] < str[ceilIndex])            ceilIndex = i;     return ceilIndex;} // Print all permutations of str in sorted orderfunction sortedPermutations ( str){    // Get size of string    let size = str.length;     // Sort the string in increasing order    str = str.split("");    str.sort(compare);     // Print permutations one by one    let isFinished = false;    while ( ! isFinished )    {        // print this permutation        console.log(str.join(""));         // Find the rightmost character which is        // smaller than its next character.        // Let us call it 'first char'        let i;        for ( i = size - 2; i >= 0; --i )        if (str[i] < str[i+1])            break;         // If there is no such character, all are        // sorted in decreasing order, means we        // just printed the last permutation and we are done.        if ( i == -1 )            isFinished = true;        else        {            // Find the ceil of 'first char' in            // right of first character.            // Ceil of a character is the smallest            // character greater than it            let ceilIndex = findCeil( str, str[i], i + 1, size - 1 );             // Swap first and second characters            let temp = str[i];            str[i] = str[ceilIndex];            str[ceilIndex] = temp;             // Sort the string on right of 'first char'            str1 = str.slice(i + 1);            str1.sort();            str = str.slice(0, i + 1);            str.push(...str1);        }    }} // Driver program to test above functionlet str = "ABCD";sortedPermutations( str ); // This code is contributed by phasing17
Output: 
ABCD
ABDC
....
....
DCAB
DCBA
Time Complexity:  O(n2 x n!) 
Auxiliary Space: O(n)
We can optimize step 4 of the above algorithm for finding next permutation. Instead of sorting the subarray after the ‘first character’, we can reverse the subarray, because the subarray we get after swapping is always sorted in non-increasing order. This optimization makes the time complexity as O(n x n!). 
See following optimized code. 
C++
C
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; // An optimized version that uses reverse instead of sort for// finding the next permutation // A utility function to reverse a string str[l..h]void reverse(char str[], int l, int h){    while (l < h)    {        swap(&str[l], &str[h]);        l++;        h--;    }} // Print all permutations of str in sorted ordervoid sortedPermutations ( char str[] ){    // Get size of string    int size = strlen(str);     // Sort the string in increasing order    qsort( str, size, sizeof( str[0] ), compare );     // Print permutations one by one    bool isFinished = false;    while ( ! isFinished )    {        // print this permutation        cout << str << endl;         // Find the rightmost character which        // is smaller than its next character.        // Let us call it 'first char'        int i;        for ( i = size - 2; i >= 0; --i )        if (str[i] < str[i+1])            break;         // If there is no such character, all        // are sorted in decreasing order,        // means we just printed the last        // permutation and we are done.        if ( i == -1 )            isFinished = true;        else        {            // Find the ceil of 'first char' in            // right of first character.            // Ceil of a character is the            // smallest character greater than it            int ceilIndex = findCeil( str, str[i], i + 1, size - 1 );             // Swap first and second characters            swap( &str[i], &str[ceilIndex] );             // reverse the string on right of 'first char'            reverse( str, i + 1, size - 1 );        }    }} // This code is contributed by rathbhupendra
// An optimized version that uses reverse instead of sort for// finding the next permutation // A utility function to reverse a string str[l..h]void reverse(char str[], int l, int h){   while (l < h)   {       swap(&str[l], &str[h]);       l++;       h--;   }} // Print all permutations of str in sorted ordervoid sortedPermutations ( char str[] ){    // Get size of string    int size = strlen(str);     // Sort the string in increasing order    qsort( str, size, sizeof( str[0] ), compare );     // Print permutations one by one    bool isFinished = false;    while ( ! isFinished )    {        // print this permutation        printf ("%s \n", str);         // Find the rightmost character which is smaller than its next        // character. Let us call it 'first char'        int i;        for ( i = size - 2; i >= 0; --i )           if (str[i] < str[i+1])              break;         // If there is no such character, all are sorted in decreasing order,        // means we just printed the last permutation and we are done.        if ( i == -1 )            isFinished = true;        else        {            // Find the ceil of 'first char' in right of first character.            // Ceil of a character is the smallest character greater than it            int ceilIndex = findCeil( str, str[i], i + 1, size - 1 );             // Swap first and second characters            swap( &str[i], &str[ceilIndex] );             // reverse the string on right of 'first char'            reverse( str, i + 1, size - 1 );        }    }}
import java.util.*; // An optimized version that uses reverse instead of sort// for finding the next permutationclass GFG{       // A utility function two swap two characters a and b    static void swap(char[] str, int i, int j)    {        char t = str[i];        str[i] = str[j];        str[j] = t;    }     // A utility function to reverse a string str[l..h]    static void reverse(char str[], int l, int h)    {        while (l < h) {            swap(str, l, h);            l++;            h--;        }    }     // This function finds the index of the smallest    // character which is greater than 'first' and is    // present in str[l..h]    static int findCeil(char str[], char first, int l,                        int h)    {        // initialize index of ceiling element        int ceilIndex = l;         // Now iterate through rest of the elements and find        // the smallest character greater than 'first'        for (int i = l + 1; i <= h; i++)            if (str[i] > first && str[i] < str[ceilIndex])                ceilIndex = i;         return ceilIndex;    }     // Print all permutations of str in sorted order    static void sortedPermutations(char str[])    {        // Get size of string        int size = str.length;         // Sort the string in increasing order        Arrays.sort(str);         // Print permutations one by one        boolean isFinished = false;        while (!isFinished) {            // print this permutation            System.out.println(str);             // Find the rightmost character which is            // smaller than its next character.            // Let us call it 'first char'            int i;            for (i = size - 2; i >= 0; --i)                if (str[i] < str[i + 1])                    break;             // If there is no such character, all are            // sorted in decreasing order, means we            // just printed the last permutation and we are            // done.            if (i == -1)                isFinished = true;            else {                // Find the ceil of 'first char' in                // right of first character.                // Ceil of a character is the smallest                // character greater than it                int ceilIndex = findCeil(str, str[i], i + 1,                                         size - 1);                 // Swap first and second characters                swap(str, i, ceilIndex);                 // reverse the string on right of 'first                // char'                reverse(str, i + 1, size - 1);            }        }    }     // Driver program to test above function    public static void main(String[] args)    {        char str[] = "ABCD".toCharArray();        sortedPermutations(str);    }} // This code is contributed by Swarn Pallav Bhaskar
# An optimized version that uses reverse# instead of sort for finding the next# permutation # A utility function to reverse a# string str[l..h]def reverse(str, l, h):         while (l < h) :        str[l], str[h] = str[h], str[l]        l += 1        h -= 1             return str     def findCeil(str, c, k, n):         ans = -1    val = c         for i in range(k, n + 1):        if str[i] > c and str[i] < val:            val = str[i]            ans = i                 return ans             # Print all permutations of str in sorted orderdef sortedPermutations(str):         # Get size of string    size = len(str)     # Sort the string in increasing order    str = ''.join(sorted(str))     # Print permutations one by one    isFinished = False         while (not isFinished):                 # Print this permutation        print(str)         # Find the rightmost character which        # is smaller than its next character.        # Let us call it 'first char'         for i in range(size - 2, -1, -1):            if (str[i] < str[i + 1]):                break         # If there is no such character, all        # are sorted in decreasing order,        # means we just printed the last        # permutation and we are done.        if (i == -1):            isFinished = True        else:                         # Find the ceil of 'first char' in            # right of first character.            # Ceil of a character is the            # smallest character greater than it            ceilIndex = findCeil(str, str[i], i + 1,                                           size - 1)             # Swap first and second characters            str[i], str[ceilIndex] =  str[ceilIndex], str[i]             # Reverse the string on right of 'first char'            str = reverse(str, i + 1, size - 1)             # This code is contributed by rohan07
using System; // An optimized version that uses reverse instead of sort// for finding the next permutationpublic class GFG {     // A utility function two swap two characters a and b    static void swap(char[] str, int i, int j) {        char t = str[i];        str[i] = str[j];        str[j] = t;    }     // A utility function to reverse a string str[l..h]    static void reverse(char []str, int l, int h) {        while (l < h) {            swap(str, l, h);            l++;            h--;        }    }     // This function finds the index of the smallest    // character which is greater than 'first' and is    // present in str[l..h]    static int findCeil(char []str, char first, int l, int h) {        // initialize index of ceiling element        int ceilIndex = l;         // Now iterate through rest of the elements and find        // the smallest character greater than 'first'        for (int i = l + 1; i <= h; i++)            if (str[i] > first && str[i] < str[ceilIndex])                ceilIndex = i;         return ceilIndex;    }     // Print all permutations of str in sorted order    static void sortedPermutations(char []str) {        // Get size of string        int size = str.Length;         // Sort the string in increasing order        Array.Sort(str);         // Print permutations one by one        bool isFinished = false;        while (!isFinished) {            // print this permutation            Console.WriteLine(str);             // Find the rightmost character which is            // smaller than its next character.            // Let us call it 'first char'            int i;            for (i = size - 2; i >= 0; --i)                if (str[i] < str[i + 1])                    break;             // If there is no such character, all are            // sorted in decreasing order, means we            // just printed the last permutation and we are            // done.            if (i == -1)                isFinished = true;            else {                // Find the ceil of 'first char' in                // right of first character.                // Ceil of a character is the smallest                // character greater than it                int ceilIndex = findCeil(str, str[i], i + 1, size - 1);                 // Swap first and second characters                swap(str, i, ceilIndex);                 // reverse the string on right of 'first                // char'                reverse(str, i + 1, size - 1);            }        }    }     // Driver program to test above function    public static void Main(String[] args) {        char []str = "ABCD".ToCharArray();        sortedPermutations(str);    }} // This code contributed by umadevi9616
<script> // An optimized version that uses reverse instead of sort// for finding the next permutation   // A utility function two swap two characters a and b    function swap( str , i , j) {        var t = str[i];        str[i] = str[j];        str[j] = t;    }     // A utility function to reverse a string str[l..h]    function reverse( str , l , h) {        while (l < h) {            swap(str, l, h);            l++;            h--;        }    }     // This function finds the index of the smallest    // character which is greater than 'first' and is    // present in str[l..h]    function findCeil( str,  first , l , h) {        // initialize index of ceiling element        var ceilIndex = l;         // Now iterate through rest of the elements and find        // the smallest character greater than 'first'        for (i = l + 1; i <= h; i++)            if (str[i] > first && str[i] < str[ceilIndex])                ceilIndex = i;         return ceilIndex;    }     // Print all permutations of str in sorted order    function sortedPermutations(str) {        // Get size of string        var size = str.length;         // Sort the string in increasing order              str.sort();         // Print permutations one by one        var isFinished = false;        while (!isFinished) {            // print this permutation            var st = str.join("");            document.write(st+"</br>");             // Find the rightmost character which is            // smaller than its next character.            // Let us call it 'first char'            var i;            for (i = size - 2; i >= 0; --i)                if (str[i] < str[i + 1])                    break;             // If there is no such character, all are            // sorted in decreasing order, means we            // just printed the last permutation and we are            // done.            if (i == -1)                isFinished = true;            else {                // Find the ceil of 'first char' in                // right of first character.                // Ceil of a character is the smallest                // character greater than it                var ceilIndex = findCeil(str, str[i], i + 1, size - 1);                 // Swap first and second characters                swap(str, i, ceilIndex);                 // reverse the string on right of 'first                // char'                reverse(str, i + 1, size - 1);            }        }    }     // Driver program to test above function        var str = "ABCD";           str = str.split("");        sortedPermutations(str); // This code is contributed by umadevi9616</script>
Time Complexity: O(n*n!)
Auxiliary Space: O(n)
The above programs print duplicate permutation when characters are repeated. We can avoid it by keeping track of the previous permutation. While printing, if the current permutation is same as previous permutation, we won’t be printing it.This article is compiled by Aashish Barnwal and reviewed by GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
rathbhupendra
shubham_singh
rohan07
swarnpallav
umadevi9616
simranarora5sos
lucidcoder121
phasing17
lexicographic-ordering
permutation
Combinatorial
Mathematical
Strings
Strings
Mathematical
permutation
Combinatorial
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.