递归求字符全排列

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=10;
char n[N];
char path[N];
bool used[N];

void dfs(int u)
{
    if(u==strlen(n))
    {
        for(int i=0;i<strlen(n);i++)    cout<<path[i];
        cout<<endl;
        return;
    }
    for(int i=0;i<strlen(n);i++)
    {
        if(!used[i])
        {
            path[u]=n[i];
            cout<<"path["<<u<<"]"<<"=n["<<i<<"]"<<endl;
            used[i]=true;
            cout<<"used["<<i<<"]=true"<<endl;
            dfs(u+1);
            used[i]=false;
            cout<<"used["<<i<<"]=false"<<endl;
        }
        else
        {
            cout<<n[i]<<"已经使用了"<<endl;
        }
    }
}

int main()
{
    cin>>n;
    sort(n,n+strlen(n));
    dfs(0);
    return 0;
}

输入abc

输出结果

path[0]=n[0]
used[0]=true
a已经使用了
path[1]=n[1]
used[1]=true
a已经使用了
b已经使用了
path[2]=n[2]
used[2]=true
abc
used[2]=false
used[1]=false
path[1]=n[2]
used[2]=true
a已经使用了
path[2]=n[1]
used[1]=true
acb
used[1]=false
c已经使用了
used[2]=false
used[0]=false
path[0]=n[1]
used[1]=true
path[1]=n[0]
used[0]=true
a已经使用了
b已经使用了
path[2]=n[2]
used[2]=true
bac
used[2]=false
used[0]=false
b已经使用了
path[1]=n[2]
used[2]=true
path[2]=n[0]
used[0]=true
bca
used[0]=false
b已经使用了
c已经使用了
used[2]=false
used[1]=false
path[0]=n[2]
used[2]=true
path[1]=n[0]
used[0]=true
a已经使用了
path[2]=n[1]
used[1]=true
cab
used[1]=false
c已经使用了
used[0]=false
path[1]=n[1]
used[1]=true
path[2]=n[0]
used[0]=true
cba
used[0]=false
b已经使用了
c已经使用了
used[1]=false
c已经使用了
used[2]=false

 

 

如果每个字母可以重复使用

 

#include<iostream>
#include<cstring>
using namespace std;

char path[10];
char t[10];

void dfs(int n,int l)
{
    if(n==l)
    {
        n=0;
        cout<<path<<endl;
        return;
    }
    
    for(int i=0;i<l;i++)
    {
        path[n]=t[i];
        dfs(n+1,l);
    }
}

int main()
{

    cin>>t;
    dfs(0,strlen(t));
}