Algorithm 制作不同字长的词表？

我想创建不同字长的单词列表。我的src为

长度=1：

for(int a=97;a<=122;a++)
   String foo=String.valueOf((char)a);

---

for（int a=97；a如果字符串是一个数字，只需添加一个直到数字溢出即可获得所有可能的值

你可以对字符串使用同样的方法；只考虑每个字符为一个数字；添加一个最右边的字符；如果它包含，增加下一个字符，等等。
// for strings of size N
char *str = malloc(N+1);
// init
str[N] = 0;
for (i=0, i<N, i++) str[i]='a';

int done = 0;
while (!done)
{
    for(i=N-1; i>=0; i--)
    {
        str[i] += 1;
        if (str[i] == 'z'+1) 
        {
            if (N==0) done = 1;
            str[i] = 'a';
        }
        else break;
    }
    // do something with str
}

//用于大小为N的字符串
char*str=malloc（N+1）；
//初始化
str[N]=0；
对于（i=0，i=0；i--）
{
str[i]+=1；
如果（str[i]='z'+1）
{
如果（N==0）完成=1；
str[i]=“a”；
}
否则就断了；
}
//用str做点什么
}
如果字符串是一个数字，只需添加一个数字，直到数字溢出，即可获得所有可能的值

你可以对字符串使用同样的方法；只考虑每个字符为一个数字；添加一个最右边的字符；如果它包含，增加下一个字符，等等。
// for strings of size N
char *str = malloc(N+1);
// init
str[N] = 0;
for (i=0, i<N, i++) str[i]='a';

int done = 0;
while (!done)
{
    for(i=N-1; i>=0; i--)
    {
        str[i] += 1;
        if (str[i] == 'z'+1) 
        {
            if (N==0) done = 1;
            str[i] = 'a';
        }
        else break;
    }
    // do something with str
}

//用于大小为N的字符串
char*str=malloc（N+1）；
//初始化
str[N]=0；
对于（i=0，i=0；i--）
{
str[i]+=1；
如果（str[i]='z'+1）
{
如果（N==0）完成=1；
str[i]=“a”；
}
否则就断了；
}
//用str做点什么
}
注意下面的方法效率相当低。可以通过使用使用StringBuilder的辅助方法来提高效率，然后在完成后在主方法中完成字符串

无论如何，递归是处理这个问题的最好方法

List<String> generate(int len) {
    if(len == 1) {
        List<String> strings = new LinkedList<String>();
        // notice I'm putting a char here, not an int
        for(char a=97;a<=122;a++) strings.add(String.valueOf(a));
        return strings;
    }
    List<String> shortStrings = generate(len - 1);
    List<String> strings = new LinkedList<String>();
    for(String shortString : shortStrings)
        for(char a=97;a<=122;a++) strings.add(shortString + A);
    return strings;
}

列表生成（int len）{
如果（len==1）{
列表字符串=新的LinkedList（）；
//注意，我在这里放了一个字符，不是int
对于（char a=97；a请注意，下面的方法效率相当低。可以通过使用使用StringBuilder的辅助方法来提高效率，然后在完成后在主方法中完成字符串

无论如何，递归是处理这个问题的最好方法

List<String> generate(int len) {
    if(len == 1) {
        List<String> strings = new LinkedList<String>();
        // notice I'm putting a char here, not an int
        for(char a=97;a<=122;a++) strings.add(String.valueOf(a));
        return strings;
    }
    List<String> shortStrings = generate(len - 1);
    List<String> strings = new LinkedList<String>();
    for(String shortString : shortStrings)
        for(char a=97;a<=122;a++) strings.add(shortString + A);
    return strings;
}

列表生成（int len）{
如果（len==1）{
列表字符串=新的LinkedList（）；
//注意，我在这里放了一个字符，不是int
对于（char a=97；a，正如Tejs建议的那样，您需要使用递归。您不能编写具有动态深度的循环，但可以递归到任何级别（至少在堆栈空间用完之前）：

如果你想包含所有达到所需长度的字符串，这是一个简单的调整-只要始终将字符串添加到字典中，但只有在当前深度大于零时才递归

希望这能有所帮助！
正如Tejs建议的那样，您需要使用递归。您不能编写具有动态深度的循环，但可以递归到任何级别（至少在堆栈空间用完之前）：

如果你想包含所有达到所需长度的字符串，这是一个简单的调整-只要始终将字符串添加到字典中，但只有在当前深度大于零时才递归

希望这有帮助！
如果我没有完全错，你要做的是生成所有可能的长度字符串
如果我没有完全错，你要做的是生成所有可能的长度字符串
这看起来像Java…我对吗？是的，但它在哪种语言听起来像你一样没有区别想要使用递归。对于每个深度，你在单词中添加另一个字符。这些循环目前没有任何作用，只是创建一个局部变量-它实际上在内部做什么吗？这看起来像Java…我说的对吗？是的，但它在哪种语言中听起来就像你只想使用递归一样。对于每个深度，yo在单词中添加另一个字符。这些循环目前不起任何作用，只需创建一个局部变量-它实际上在内部起作用吗？
dictionary = new Dictionary;
generate(dictionary, '', depth);

string getString(int val) {
    string str = "";
    while (val>=0) {
        int rem = val%26; // as there are 26 characters in english
        str = str + charToString('a'+rem);
        val /= 26;
    }
    return str;
}

void listStrings(int N) {
    int max = 26^N-1;
    string str;
    for(int i=1; i<=max; ++i) {
        str = getString(i);
        doSomething(str); // maybe print it or store in file
    }
}