在递归中查找Java字符串数组的无序序列

我必须创建一个算法，使用字符串数组显示所有可用的固定长度无序序列。该方法需要递归，并且只能接受一个整数。它还需要返回一个字符串数组

假设我有“ab”和“ba”。 当我用该方法给出int 2时，应该找到以下固定长度的无序序列：

abab
abba
baba
baab

我已经工作了好几个小时了，我有一种感觉，对于这件简单的事情，我工作得太辛苦了。我有不同类型的代码，我几乎让它工作（abba显示了两次而不是另一个序列），但我忘记了在数组中返回它，所以导致了问题。。。 我拥有的代码如下所示，但尚未完成且无法运行：

static String[] syllables = {"ab", "ba"};
static String[] syllableWord;

public static void main(String[] args) {
    int amountOfSillables = 2;
    syllableWord = String[(int)Math.pow(amountOfSillables, amountOfSillables)];
    String[] syllableWords = findSequences(amountOfSillables); // I may only use one parameter,
                                     // which is 2 but should work with any number

    for (int i = 0; i < syllableWords.length; i++) {
        System.out.println(syllableWords[i]);
    }
}

public static String[] findSequences(int n) {
    if (n == 0) {
        return syllableWord;
    }
    else {
        for (int i = 0; i < syllables.length; i++) {
            syllableWord += syllables[i]; // Doesn't work because syllableWord is an array.
                                          // When it's a String this would kinda work, but it 
                                          // needs to be an array.
            findSequences(n - 1);
            syllableWord = syllableWord.substring(2); // Also doesn't work when it's an array.
        }
    }
}

静态字符串[]音节={“ab”，“ba”}；
静态字符串[]音节词；
公共静态void main（字符串[]args）{
int amountOfSillables=2；
音节词=字符串[（int）Math.pow（amountOfSillables，amountOfSillables）]；
String[]SydelleWords=findSequences（amountOfSillables）；//我只能使用一个参数，
//这是2，但应该与任何数字一起使用
for（int i=0；i

有人能帮我吗？这让我发疯了…

像这样的事？（使用ArrayList比Array更智能，因为您不需要管理阵列大小，这取决于您的需要）

公共静态列表perm（int n）{
列表结果=新建ArrayList（）；
如果（n==1）{
返回数组.asList（音节）；
}
for（字符串s：音节）{
for（字符串前缀：perm（n-1））{
结果。添加（s+前缀）；
}
}
返回结果；
}

我没有完全使用您的模板，我在递归调用中使用的不止是一个整数

我只使用一个数组，在递归调用之后很少进行后期计算，因此它应该非常有效

public static String[] perm(String[] data) {
    int n = (int) Math.pow(data.length, data.length);
    String[] result = new String[n];
    algo(data, result, 0, n, new StringBuilder());
    return result;
}

private static void algo(String[] data, String[] result, int offset, int width, StringBuilder acc) {
    if(width == 1) {
        result[offset] = acc.toString();
        return;
    }
    width /= data.length;
    for(int i=0; i<data.length; i++) {
        acc.append(data[i]);
        algo(data, result, offset+i*width, width, acc);
        int s = acc.length();
        acc.delete(s-data[i].length(), s);
    }
}

公共静态字符串[]perm（字符串[]数据）{
int n=（int）Math.pow（data.length，data.length）；
字符串[]结果=新字符串[n]；
algo（数据、结果、0、n、新StringBuilder（））；
返回结果；
}
私有静态void算法（字符串[]数据、字符串[]结果、整数偏移、整数宽度、StringBuilder acc）{
如果（宽度==1）{
结果[偏移量]=根据toString（）；
返回；
}
宽度/=数据长度；
对于（int i=0；i假设您只想显示该值，则以下操作应有效：

public static void main(String args[])
{

    final String[] syllables = new String[] { "ab", "ba" };
    final List<String> path = new ArrayList<String>();
    recursiveDisplay(syllables, path, 0);

}

private static void recursiveDisplay(final String[] syllables, List<String> path, final int index)
{

    if (index < syllables.length - 1)
        for (int i = 0; i < syllables.length; i++)
        {
            path.add(syllables[i]);//add current token
            recursiveDisplay(syllables, path, index + 1);//process updated path
            path.remove(path.size() - 1);//remove processed token
        }
    else
    {
        // we have reached the end of the tree
        // let's display all possible combination of this path

        StringBuilder buidler = new StringBuilder();
        for (final String token : path)
            buidler.append(token);

        for (final String token : syllables)
            System.out.println(buidler + token);
    }

}

publicstaticvoidmain（字符串参数[]）
{
最后一个字符串[]音节=新字符串[]{“ab”，“ba”}；
最终列表路径=新的ArrayList（）；
递归显示（音节，路径，0）；
}
私有静态void recursiveDisplay（最终字符串[]音节，列表路径，最终整数索引）
{
如果（索引<音节.长度-1）
for（int i=0；i<音节.length；i++）
{
add（音节[i]）；//添加当前标记
递归显示（音节、路径、索引+1）；//处理更新的路径
path.remove（path.size（）-1）；//删除已处理的令牌
}
其他的
{
//我们已经到了树的尽头
//让我们显示此路径的所有可能组合
StringBuilder buidler=新建StringBuilder（）；
for（最终字符串标记：路径）
buidler.append（令牌）；
for（最后一个字符串标记：音节）
System.out.println（buildler+token）；
}
}
SydeleWord不能从perm方法访问。因为SydeleWord是在main方法中定义的局部变量，为什么您要求递归调用中只有一个参数（整数）？您不能使用+=”将项添加到数组中。此代码中有许多编译错误。这不是您要查找的吗？和“abab”不是“ab”和“ba”的排列。您正在尝试查找固定长度的无序序列，而不是排列。这实际上是我正在寻找的，但我不能使用ArrayList（尽管我知道它更方便，因为它没有固定大小…）我的意思是作为返回值。但是，我可以在方法中使用它，并在返回它之前将其转换为常规数组。谢谢！我修改了您的代码，使返回值为字符串数组。String[]stockArr=result.toArray（新字符串[result.size（））；return stockArr；它可以工作。感谢大家与我一起思考！
public static void main(String args[])
{

    final String[] syllables = new String[] { "ab", "ba" };
    final List<String> path = new ArrayList<String>();
    recursiveDisplay(syllables, path, 0);

}

private static void recursiveDisplay(final String[] syllables, List<String> path, final int index)
{

    if (index < syllables.length - 1)
        for (int i = 0; i < syllables.length; i++)
        {
            path.add(syllables[i]);//add current token
            recursiveDisplay(syllables, path, index + 1);//process updated path
            path.remove(path.size() - 1);//remove processed token
        }
    else
    {
        // we have reached the end of the tree
        // let's display all possible combination of this path

        StringBuilder buidler = new StringBuilder();
        for (final String token : path)
            buidler.append(token);

        for (final String token : syllables)
            System.out.println(buidler + token);
    }

}