 GeeksforGeeks App
Open App Browser
Continue

# Lexicographically Next Permutation of given String

All the permutations of a word when arranged in a dictionary, the order of words so obtained is called lexicographical order. in Simple words, it is the one that has all its elements sorted in ascending order, and the largest has all its elements sorted in descending order.

lexicographically is nothing but the greater permutation of it.

For reference: a b c d e f g h i j k l m n o p q r s t u v w x y z

For example, lexicographically next permutation of “gfg” is “ggf” and the next permutation of “acb” is “bac”.
Note: In some cases, the next lexicographically greater word might not exist, e.g, “aaa” and “edcba”.

In C++, there is a specific function that saves us from a lot of code. It’s in the file #include <algorithm>. The function is next_permutation(a.begin(), a.end())
It returns ‘true’ if the function could rearrange the object as a lexicographically greater permutation. Otherwise, the function returns ‘false’.

Example:

## CPP

 `// C++ program to demonstrate next lexicographically``// greater permutation of a word` `#include ``#include ` `using` `namespace` `std;` `int` `main()``{``    ``string s = { ``"gfg"` `};``    ``bool` `val``        ``= next_permutation(s.begin(),``                        ``s.end());``    ``if` `(val == ``false``)``        ``cout << ``"No Word Possible"``            ``<< endl;``    ``else``        ``cout << s << endl;``    ``return` `0;``}`

Output:

`ggf`

Time Complexity: O(N), where N is the length of the given string.
Auxiliary Space: O(1), as constant extra space is used.

The same program can also be implemented without using STL. Below is the code snippet for the same.

The Idea is Based on the Following Facts:

1. A sequence sorted in descending order does not have the next permutation. For example “edcba” does not have the next permutation.
2. For a sequence that is not sorted in descending order for example “abedc”, we can follow these steps.
• a) Traverse from the right and find the first item that is not following the ascending order. For example in “abedc”, the character ‘b’ does not follow the ascending order.
• b) Swap the found character with the closest greater (or smallest greater) element on the right side of it. In the case of “abedc”, we have ‘c’ as the closest greater element. After swapping ‘b’ and ‘c’, the string becomes “acedb”.
• c) After swapping, reverse the string after the position of the character found in step a. After reversing the substring “edb” of “acedb”, we get “acbde” which is the required next permutation.

Optimizations in steps b) and c)
a) Since the sequence is sorted in decreasing order, we can use binary search to find the closest greater element.

c) Since the sequence is already sorted in decreasing order (even after swapping as we swapped with the closest greater), we can get the sequence sorted (in increasing order) after reversing it.

## CPP

 `// C++ program to demonstrate``// the next lexicographically``// greater permutation of a word``#include ` `using` `namespace` `std;` `void` `swap(``char``* a, ``char``* b)``{``    ``if` `(*a == *b)``        ``return``;``    ``*a ^= *b;``    ``*b ^= *a;``    ``*a ^= *b;``}``void` `rev(string& s, ``int` `l, ``int` `r)``{``    ``while` `(l < r)``        ``swap(&s[l++], &s[r--]);``}` `int` `bsearch``(string& s, ``int` `l, ``int` `r, ``int` `key)``{``    ``int` `index = -1;``    ``while` `(l <= r) {``        ``int` `mid = l + (r - l) / 2;``        ``if` `(s[mid] <= key)``            ``r = mid - 1;``        ``else` `{``            ``l = mid + 1;``            ``if` `(index == -1 || s[index] >= s[mid])``                ``index = mid;``        ``}``    ``}``    ``return` `index;``}` `bool` `nextpermutation(string& s)``{``    ``int` `len = s.length(), i = len - 2;``    ``while` `(i >= 0 && s[i] >= s[i + 1])``        ``--i;``    ``if` `(i < 0)``        ``return` `false``;``    ``else` `{``        ``int` `index = ``bsearch``(s, i + 1, len - 1, s[i]);``        ``swap(&s[i], &s[index]);``        ``rev(s, i + 1, len - 1);``        ``return` `true``;``    ``}``}` `// Driver code``int` `main()``{``    ``string s = { ``"gfg"` `};``    ``bool` `val = nextpermutation(s);``    ``if` `(val == ``false``)``        ``cout << ``"No Word Possible"` `<< endl;``    ``else``        ``cout << s << endl;``    ``return` `0;``}`

## Java

 `//Java implementation``import` `java.io.*;` `public` `class` `Main {``public` `static` `char``[] nextPermutation(String s) {``   ``// Convert the input string to a list of characters``    ``char``[] arr = s.toCharArray();``    ``int` `n = arr.length;``    ``int` `i = n - ``2``;``   ``// Find the largest index i such that arr[i] < arr[i+1]``    ``while` `(i >= ``0` `&& arr[i] >= arr[i+``1``]) {``        ``i--;``    ``}``   ``// If no such index exists, return "No next Permutation"``    ``if` `(i < ``0``) {``      ``String st = ``"No next Permutation possible"``;``      ``char``[] ar = st.toCharArray();``        ``return` `ar;``    ``}``    ``int` `j = n - ``1``;``  ``// Find the largest index j such that arr[i] < arr[j]``    ``while` `(j >= ``0` `&& arr[j] <= arr[i]) {``        ``j--;``    ``}``   ``// Swap arr[i] and arr[j]``    ``swap(arr, i, j);``  ``//Reverse the sublist arr[start:end+1]``    ``rev(arr, i+``1``, n-``1``);``    ``return` `arr;``}` ` ``// Function to swap two numbers``private` `static` `void` `swap(``char``[] arr, ``int` `i, ``int` `j) {``    ``char` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``}``//Function to reverse the array``private` `static` `void` `rev(``char``[] arr, ``int` `start, ``int` `end) {``    ``while` `(start < end) {``        ``swap(arr, start, end);``        ``start++;``        ``end--;``    ``}``}`` ``// Driver code``public` `static` `void` `main(String[] args)``    ``{` `        ``String str2 = ``"gfg"``;  ``// Example 2``        ``System.out.println(nextPermutation(str2));``        ` `    ``}``}`

## Python3

 `def` `next_permutation(s: ``str``) ``-``> ``str``:``   ` `    ``# Convert the input string to a list of characters``    ``arr ``=` `list``(s)``    ``n ``=` `len``(arr)``    ``i ``=` `n ``-` `2``    ` `    ``# Find the largest index i such that arr[i] < arr[i+1]``    ``while` `i >``=` `0` `and` `arr[i] >``=` `arr[i``+``1``]:``        ``i ``-``=` `1``   ` `     ``# If no such index exists, return "No next Permutation"``    ``if` `i < ``0``:``        ``return` `"No next Permutation possible"``    ``j ``=` `n ``-` `1``    ` `     ``# Find the largest index j such that arr[i] < arr[j]``    ``while` `j >``=` `0` `and` `arr[j] <``=` `arr[i]:``        ``j ``-``=` `1``    ``# Swap arr[i] and arr[j]``    ``arr[i], arr[j] ``=` `arr[j], arr[i]``    ``# Reverse the sublist arr[start:end+1]``    ``rev(arr, i``+``1``, n``-``1``)``    ``return` `''.join(arr)` ` ``# Function to reverse the array``def` `rev(arr: ``list``, start: ``int``, end: ``int``) ``-``> ``None``:``    ``while` `start < end:``        ``swap(arr, start, end)``        ``start ``+``=` `1``        ``end ``-``=` `1`` ``# Function to swap two numbers``def` `swap(arr: ``list``, i: ``int``, j: ``int``) ``-``> ``None``:``    ``temp ``=` `arr[i]``    ``arr[i] ``=` `arr[j]``    ``arr[j] ``=` `temp` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``s ``=` `"gfg"``    ``print``(next_permutation(s))`

## C#

 `using` `System;` `class` `GFG {``    ``public` `static` `char``[] NextPermutation(``string` `s) {``        ``// Convert the input string to a char array``        ``char``[] arr = s.ToCharArray();``        ``int` `n = arr.Length;``        ``int` `i = n - 2;``        ``// Find the largest index i such that arr[i] < arr[i+1]``        ``while` `(i >= 0 && arr[i] >= arr[i+1]) {``            ``i--;``        ``}``        ``// If no such index exists, return "No next Permutation"``        ``if` `(i < 0) {``            ``string` `st = ``"No next Permutation possible"``;``            ``char``[] ar = st.ToCharArray();``            ``return` `ar;``        ``}``        ``int` `j = n - 1;``        ``// Find the largest index j such that arr[i] < arr[j]``        ``while` `(j >= 0 && arr[j] <= arr[i]) {``            ``j--;``        ``}``        ``// Swap arr[i] and arr[j]``        ``Swap(arr, i, j);``        ``// Reverse the sublist arr[start:end+1]``        ``Reverse(arr, i+1, n-1);``        ``return` `arr;``    ``}` `    ``// Function to swap two numbers``    ``private` `static` `void` `Swap(``char``[] arr, ``int` `i, ``int` `j) {``        ``char` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = temp;``    ``}` `    ``// Function to reverse the array``    ``private` `static` `void` `Reverse(``char``[] arr, ``int` `start, ``int` `end) {``        ``while` `(start < end) {``            ``Swap(arr, start, end);``            ``start++;``            ``end--;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args) {``        ``string` `str2 = ``"gfg"``;  ``// Example 2``        ``Console.WriteLine(NextPermutation(str2));``    ``}``}`

## Javascript

 `function` `next_permutation(s) {``    ` `    ``// Convert the input string to a list of characters``    ``let arr = Array.from(s);``    ``let n = arr.length;``    ``let i = n - 2;``    ` `    ``// Find the largest index i such that arr[i] < arr[i+1]``    ``while` `(i >= 0 && arr[i] >= arr[i+1]) {``        ``i--;``    ``}``   ` `    ``// If no such index exists, return "No next Permutation"``    ``if` `(i < 0) {``        ``return` `"No next Permutation possible"``;``    ``}``    ``let j = n - 1;``    ` `    ``// Find the largest index j such that arr[i] < arr[j]``    ``while` `(j >= 0 && arr[j] <= arr[i]) {``        ``j--;``    ``}``    ` `    ``// Swap arr[i] and arr[j]``    ``let temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``    ` `    ``// Reverse the sublist arr[start:end+1]``    ``rev(arr, i+1, n-1);``    ``return` `arr.join(``''``);``}` `// Function to reverse the array``function` `rev(arr, start, end) {``    ``while` `(start < end) {``        ``swap(arr, start, end);``        ``start++;``        ``end--;``    ``}``}` `// Function to swap two numbers``function` `swap(arr, i, j) {``    ``let temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``}` `// Driver code``let s = ``"gfg"``;``console.log(next_permutation(s));`

Output:

`ggf`

Time Complexity:

1. In the worst case, the first step of next_permutation takes O(n) time.
2. The binary search takes O(log n) time.
3. The reverse takes O(n) time.

Overall time complexity is O(n). Where n is the length of the string.
Auxiliary Space is O(1), because no extra space is used.