Next Permutation

Last Updated : 13 Apr, 2024

Given an array arr[] of size N, the task is to print the lexicographically next greater permutation of the given array. If there does not exist any greater permutation, then print the lexicographically smallest permutation of the given array.

Examples:

Input: N = 6, arr = {1, 2, 3, 6, 5, 4}
Output: {1, 2, 4, 3, 5, 6}
Explanation: The next permutation of the given array is {1, 2, 4, 3, 5, 6}.

Input: N = 3, arr = {3, 2, 1}
Output: {1, 2, 3}
Explanation: As arr[] is the last permutation.
So, the next permutation is the lowest one.

Let’s first understand what is lexicographical order in the above-given program.

We have to check that the order of the array sequence is greater than the previous array sequence. The output will be just larger sequence of the array.

Brute Force Approach :

Find all possible permutations of the given array.
Print the Next permutation right after the er given input sequence.

Time Complexity: O(N * N!), N represents the number of elements present in the input sequence. represent all possible permutation. Therefore, It takes the time complexity O(N*N!).
Auxiliary Space: O(N), for storing the permutation in some data structure.

Using C++ in-build function:

C++ provides an in-built function called next_permutation(), that return directly lexicographically in the next greater permutation of the input.

C++

#include <bits/stdc++.h>
using namespace std;

// Function to find the next permutation
void nextPermutation(vector<int>& arr)
{
    next_permutation(arr.begin(),arr.end());
}

// Driver code
int main()
{

    // Given input array
    vector<int> arr = { 1, 2, 3, 6, 5, 4 };

    // Function call
    nextPermutation(arr);

    // Printing the answer
    for (auto i : arr) {
        cout << i << " ";
    }

    return 0;
}

Java

import java.util.Arrays;

public class NextPermutation {
    public static void GFG(int[] arr) {
        int i = arr.length - 2;
        while (i >= 0 && arr[i] >= arr[i + 1]) {
            i--;
        }
        // If no such index exists, the entire array is in descending order so reverse it
        if (i == -1) {
            reverse(arr, 0, arr.length - 1);
            return;
        }
        // Find the largest index j greater than i such that arr[i] < arr[j]
        int j = arr.length - 1;
        while (arr[j] <= arr[i]) {
            j--;
        }
        // Swap arr[i] and arr[j]
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        // Reverse the suffix starting from index i + 1
        reverse(arr, i + 1, arr.length - 1);
    }

    // Function to reverse the subarray from index start to end
    public static void reverse(int[] arr, int start, int end) {
        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }

    public static void main(String[] args) {
        // Given input array
        int[] arr = {1, 2, 3, 6, 5, 4};
        GFG(arr);
        // Printing the answer
        System.out.println(Arrays.toString(arr));
    }
}

Python3

# Function to find the next permutation
def next_permutation(arr):
    # Find the first element from the right which is smaller than the element next to it
    i = len(arr) - 2
    while i >= 0 and arr[i] >= arr[i + 1]:
        i -= 1

    if i >= 0:
        # Find the smallest element from the right which is greater than arr[i]
        j = len(arr) - 1
        while arr[j] <= arr[i]:
            j -= 1
        
        # Swap arr[i] and arr[j]
        arr[i], arr[j] = arr[j], arr[i]

    # Reverse the elements after index i to get the next permutation
    left, right = i + 1, len(arr) - 1
    while left < right:
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1

# Driver code
if __name__ == "__main__":
    # Given input array
    arr = [1, 2, 3, 6, 5, 4]

    # Function call
    next_permutation(arr)

    # Printing the answer
    print(*arr)

JavaScript

function GFG(arr) {
    let i = arr.length - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) {
        i--;
    }
    // If no such index exists, the entire array is in the descending order so reverse it
    if (i === -1) {
        arr.reverse();
        return;
    }
    // Find the largest index j greater than i such that arr[i] < arr[j]
    let j = arr.length - 1;
    while (arr[j] <= arr[i]) {
        j--;
    }
    // Swap arr[i] and arr[j]
    [arr[i], arr[j]] = [arr[j], arr[i]];
    // Reverse the suffix starting from index i + 1
    let left = i + 1, right = arr.length - 1;
    while (left < right) {
        [arr[left], arr[right]] = [arr[right], arr[left]];
        left++;
        right--;
    }
}
// Driver code
(() => {
    // Given input array
    let arr = [1, 2, 3, 6, 5, 4];
    GFG(arr);
    // Printing the answer
    console.log(arr.join(" "));
})();

Output

1 2 4 3 5 6