Next Permutation

Next Permutation - Problem

A permutation of an array of integers is an arrangement of its members into a sequence or linear order.

For example, for arr = [1,2,3], the following are all the permutations of arr: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1].

The next permutation of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the next permutation of that array is the permutation that follows it in the sorted container.

If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order).

For example:

The next permutation of arr = [1,2,3] is [1,3,2]
Similarly, the next permutation of arr = [2,3,1] is [3,1,2]
While the next permutation of arr = [3,2,1] is [1,2,3] because [3,2,1] does not have a lexicographical larger rearrangement

Given an array of integers nums, find the next permutation of nums. The replacement must be in place and use only constant extra memory.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3]

› Output: [1,3,2]

💡 Note: Find pivot at index 1 (2 < 3), find successor at index 2 (3), swap them to get [1,3,2], no suffix to reverse

Example 2 — Larger Array

$ Input: nums = [2,3,1]

› Output: [3,1,2]

💡 Note: Find pivot at index 0 (2 < 3), find successor at index 1 (3), swap to get [3,2,1], reverse suffix [2,1] to get [3,1,2]

Example 3 — Last Permutation

$ Input: nums = [3,2,1]

› Output: [1,2,3]

💡 Note: No pivot found (descending order), this is the last permutation, so reverse entire array to get first permutation [1,2,3]

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15 f Facebook 12

The key insight is that the next permutation follows a mathematical pattern. Find the rightmost ascending pair (pivot), swap the pivot with the smallest larger element to its right, then reverse the suffix. Best approach is the Next Permutation Algorithm with Time: O(n), Space: O(1).

Common Approaches

✓ Generate All Permutations

⏱️ Time: O(n!) Space: O(n!)

Generate all possible permutations of the array, sort them lexicographically, find the current permutation, and return the next one. If it's the last permutation, return the first one.

Next Permutation Algorithm

⏱️ Time: O(n) Space: O(1)

Use the standard algorithm: find the rightmost character that is smaller than its next character (pivot), find the smallest character on right side of pivot that is larger than pivot, swap them, then reverse the substring after the pivot.

Generate All Permutations — Algorithm Steps

Generate all permutations of the array
Sort permutations lexicographically
Find current permutation in the sorted list
Return the next permutation (or first if current is last)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible arrangements

Sort

Order them lexicographically

Find Next

Locate current and return next

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void reverse(int* nums, int start, int end) {
    while (start < end) {
        swap(&nums[start], &nums[end]);
        start++;
        end--;
    }
}

void solution(int* nums, int numsSize) {
    // Use the optimal algorithm instead of generating all permutations
    // Find the largest index i such that nums[i] < nums[i + 1]
    int i = numsSize - 2;
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }
    
    if (i >= 0) {
        // Find the largest index j such that nums[i] < nums[j]
        int j = numsSize - 1;
        while (nums[j] <= nums[i]) {
            j--;
        }
        swap(&nums[i], &nums[j]);
    }
    
    // Reverse the suffix starting at index i + 1
    reverse(nums, i + 1, numsSize - 1);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array manually
    int nums[1000];
    int size = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    solution(nums, size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", nums[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Generating all n! permutations and sorting them

⚠ Quadratic Growth

Space Complexity

O(n!)

Storing all n! permutations in memory

⚠ Quadratic Space

314.5K Views

Medium Frequency

~25 min Avg. Time

8.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler