JavaScript Program to Find Lexicographically Next Permutation
Last Updated :
07 Nov, 2023
Given an array of distinct integers, we want to find the lexicographically next permutation of those elements. In simple words, when all the possible permutations of an array are placed in a sorted order, it is the lexicographic order of those permutations. In this case, we have to find the next greater permutation of the elements in this sorted or lexicographic order.
Examples:
Example 1:
Input: [1, 2, 3]
Output: [1, 3, 2]
Explanation: If all the permutations of these elements are arranged in a sorted order:
[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]
Here, next greater permutation of [1, 2, 3] is [1, 3, 2].
Example 2:
Input: [6, 3, 4, 7, 1]
Output: [6, 3, 7, 1, 4]
Explanation: If all the permutations of these elements are arranged in a sorted order,
next greater permutation of [6, 3, 4, 7, 1] is [6, 3, 7, 1, 4].
Approach 1: Brute Force Approach
As a brute force approach, we can generate all the possible permutations of the given array and store all the generated sequences. Then we sort all these arrays in increasing order and find the lexicographically next permutation by a simple searching technique.
Algorithm:
- Create a recursive function called permute that generates all the possible permutations of the given array by swapping the elements.
- Keep storing the generated combinations in another array named as total.
- Then iterate through this array and compare each one to the input array to find a match.
- Use JSON.stringify to compare the arrays.
- Once we find our input array, just return the next array in the traversal which will be our lexicographically next permutation.
- In a case, if there is no such permutation, we print a message that states no permutation possible.
Example: Below is the implementation of the above approach
Javascript
const permute = (arr, idx, res) => {
if (idx === arr.length - 1) {
res.push([...arr]);
return ;
}
const n = arr.length;
for (let i = idx; i < n; i++) {
[arr[idx], arr[i]] = [arr[i], arr[idx]];
permute(arr, idx + 1, res);
[arr[idx], arr[i]] = [arr[i], arr[idx]];
}
};
function generatePermutations(arr) {
const res = [];
permute(arr, 0, res);
return res;
}
let arr = [1, 2, 3];
let total = generatePermutations(arr);
const n = total.length;
total.sort();
let ans = null ;
if (JSON.stringify(total[n - 1]) ===
JSON.stringify(arr)) {
ans = total[0];
}
for (let i = 0; i < n - 1; i++) {
if (JSON.stringify(total[i]) ===
JSON.stringify(arr)) {
ans = total[i + 1];
break ;
}
}
if (ans) {
console.log(ans);
}
else {
console.log( "No next permutation found" );
}
|
Time Complexity: O(N!*N)
Space Complexity: O(1)
Method 2: Optimal Approach
If we observe the pattern, we find that in all these generated permutations, there exists an index such that the part to its right is decreasingly sorted. On traversing the array backward (from n-1), it is sorted in ascending order till this index i.
Algorithm:
- Traverse through the array from the end (n-1).
- Find an element that is smaller than its right neighbor. Let’s call it arr[i].
- In case no such element is found, that means the array is sorted in decreasing order. This indicates that it is the largest possible permutation of the array. So we return the reverse of the array as the next permutation.
- Once we find arr[i], we need to find the smallest element to its right that is greater than arr[i]. We will call that element as arr[j].
- Now swap arr[i] and arr[j].
- Reverse the part of the array to the right of arr[i]. That means from indices i+1 to n-1.
- Return the array and print the answer.
Example: Below is the implementation of the above approach
Javascript
function nextPermutation(arr) {
const n = arr.length;
let idx = -1;
for (let i = n - 2; i >= 0; i--) {
if (arr[i] < arr[i + 1]) {
idx = i;
break ;
}
}
if (idx === -1) {
arr.reverse();
return arr;
}
for (let j = n - 1; j > idx; j--) {
if (arr[j] > arr[idx]) {
[arr[j], arr[idx]] = [arr[idx], arr[j]];
break ;
}
}
let left = idx + 1;
let right = n - 1;
while (left < right) {
[arr[left], arr[right]] = [arr[right], arr[left]];
left++;
right--;
}
return arr;
}
const arr = [5, 2, 9, 8];
const ans = nextPermutation(arr);
console.log(ans);
|
Time Complexity: O(N)
Space Complexity: O(1)
Share your thoughts in the comments
Please Login to comment...