Permutations of given String

Last Updated : 9 Oct, 2026

Given a string s. Find all permutations  of a given string. Return the permutations in lexicographically non-decreasing order.

Examples:

Input: s = "ABC"
Output: ["ABC", "ACB", "BAC", "BCA", "CAB", "CBA"]

Input: s = "XY"
Output: ["XY", "YX"]

Input: s = "AAA"
Output: "AAA", "AAA", "AAA", "AAA", "AAA", "AAA"

Try It Yourself
redirect icon

[Approach] Recursion and Swapping - O(n! * n) Time

To keep the permutations sorted, we first sort the initial given string and then generate all permutations using the following steps..

  • We fix the first position and try every character in that position.
  • After we fix the first position, we recursive repeat the process for the remaining string.
  • Once we generate all permutations beginning with the current character, to bring the next character at its position in current string, we swap the next character, with the current character.
4
C++ 
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// Generate permutations using swapping
void recurPermute(int index, string &s, vector<string> &res) {
    if (index == s.size()) {
        res.push_back(s);   
        return;
    }

    for (int i = index; i < s.size(); i++) {
        swap(s[index], s[i]);

        // fix current position and recurse
        recurPermute(index + 1, s, res);

        // backtrack
        swap(s[index], s[i]);
    }
}

vector<string> permutation(string &s) {
    vector<string> res;

    recurPermute(0, s, res);

    // sort lexicographically
    sort(res.begin(), res.end());

    return res;
}

int main() {
    string s = "AAB";

    vector<string> res = permutation(s);

    for (auto x : res) cout << x << " ";

    return 0;
}
Java 
import java.util.ArrayList;
import java.util.Collections;

// Generate permutations using swapping
public class Main {
    public static void recurPermute(int index, StringBuilder s, ArrayList<String> res) {
        if (index == s.length()) {
            res.add(s.toString());
            return;
        }

        for (int i = index; i < s.length(); i++) {
            char temp = s.charAt(index);
            s.setCharAt(index, s.charAt(i));
            s.setCharAt(i, temp);

            // fix current position and recurse
            recurPermute(index + 1, s, res);

            // backtrack
            temp = s.charAt(index);
            s.setCharAt(index, s.charAt(i));
            s.setCharAt(i, temp);
        }
    }

    public static ArrayList<String> permutation(String s) {
        ArrayList<String> res = new ArrayList<>();

        recurPermute(0, new StringBuilder(s), res);

        // sort lexicographically
        Collections.sort(res);

        return res;
    }

    public static void main(String[] args) {
        String s = "AAB";

        ArrayList<String> res = permutation(s);

        for (String x : res) System.out.print(x + " ");
    }
}
Python 
from typing import List

# Generate permutations using swapping
def recurPermute(index, s, res):
    if index == len(s):
        res.append(''.join(s))
        return

    for i in range(index, len(s)):
        s[index], s[i] = s[i], s[index]

        # fix current position and recurse
        recurPermute(index + 1, s, res)

        # backtrack
        s[index], s[i] = s[i], s[index]

def permutation(s):
    res = []

    s = list(s)

    recurPermute(0, s, res)

    # sort lexicographically
    res.sort()

    return res

if __name__ == '__main__':
    s = "AAB"

    res = permutation(s)

    for x in res: print(x, end=' ')
C# 
using System;
using System.Collections.Generic;

class GFG {

    public void permutations(string str, int i, int n, List<string> v) {

        // Base condition
        if (i == n - 1) {
            v.Add(str);
            return;
        }

        // Generate permutations
        for (int j = i; j < n; j++) {

            // Swap characters
            char[] charArray = str.ToCharArray();
            char temp = charArray[i];
            charArray[i] = charArray[j];
            charArray[j] = temp;

            str = new string(charArray);

            permutations(str, i + 1, n, v);

            // Backtrack
            charArray = str.ToCharArray();
            temp = charArray[i];
            charArray[i] = charArray[j];
            charArray[j] = temp;

            str = new string(charArray);
        }
    }

    public List<string> permutation(string s) {
        List<string> v = new List<string>();

        permutations(s, 0, s.Length, v);

        v.Sort();

        return v;
    }

    static void Main() {

        string s = "AAB";

        GFG obj = new GFG();

        var res = obj.permutation(s);

        foreach (var x in res) {
            Console.Write(x + " ");
        }
    }
}
JavaScript 
// Generate permutations using swapping
function recurPermute(index, s, res) {
    if (index === s.length) {
        res.push(s.join(''));
        return;
    }

    for (let i = index; i < s.length; i++) {
        [s[index], s[i]] = [s[i], s[index]];

        // fix current position and recurse
        recurPermute(index + 1, s, res);

        // backtrack
        [s[index], s[i]] = [s[i], s[index]];
    }
}

function permutation(s) {
    const res = [];

    s = s.split('');

    recurPermute(0, s, res);

    // sort lexicographically
    res.sort();

    return res;
}

const s = "AAB";
const res = permutation(s);

for (const x of res) console.log(x);

Output
AAB AAB ABA ABA BAA BAA

Related articles:

Comment

Explore