Java 字符串的有序固定长度组合

我需要编写一个函数来查找字符串可能的固定长度组合。需要的是，并非所有梳子都是必需的。例如，如果字符串是“abcde”，我们需要长度为3的combis，那么函数必须返回以下内容：

abc
abd
abe
acd
ace
ade
bcd
bde
bce
cde

没有别的了。我一直在尝试使用递归，但事情并没有像预期的那样成功。我也看到过一些类似的问题，但从中得不到多少东西。算法或代码（C，C++，java），欢迎大家帮忙。谢谢

注意：需要订购这些组合。也就是说，字符的顺序应该与输入字符串中的顺序相同

由于您的需求的特定长度为3，请将

字符串

拆分为3的块，然后应用算法

从3的

字符串中留出一个字符，然后计算剩余2个字符的可能排列

将一个字符放在计算置换的所有可能位置上

重复上述步骤

---

在有三个输入的情况下，有三个索引，最初设置为输入字符串的前三个索引。打印出来，然后将最后一个索引增加1，然后打印出所有索引。继续，直到到达输入字符串的末尾，然后增加第二个索引，并将第三个索引重置为第二个索引之后的下一个索引。继续，直到第二个索引是倒数第二个字符，然后增加第一个索引，并将第二个和第三个连续放置在第一个之后。继续

让我试着举例说明：

Input: [abcde] ^^^ 123 Output: abc Next iteration: Input: [abcde] ^^ ^ 12 3 Output: abd Next iteration: Input: [abcde] ^^ ^ 12 3 Output: abe Next iteration: Input: [abcde] ^ ^^ 1 23 Output: acd Next iteration: Input: [abcde] ^ ^ ^ 1 2 3 Output: ace Next iteration: Input: [abcde] ^^^ 123 Output: bcd Next iteration: Input: [abcde] ^^ ^ 12 3 Output: bce Next iteration: Input: [abcde] ^ ^^ 1 23 Output: bde Next iteration: Input: [abcde] ^^^ 123 Output: cde 输入：[abcde] ^^^ 123 产出：abc 下一次迭代： 输入：[abcde] ^^ ^ 12 3 输出：abd 下一次迭代： 输入：[abcde] ^^ ^ 12 3 产出：安倍 下一次迭代： 输入：[abcde] ^ ^^ 1 23 输出：acd 下一次迭代： 输入：[abcde] ^ ^ ^ 1 2 3 输出：ace 下一次迭代： 输入：[abcde] ^^^ 123 输出：bcd 下一次迭代： 输入：[abcde] ^^ ^ 12 3 输出：bce 下一次迭代： 输入：[abcde] ^ ^^ 1 23 产出：溴二苯醚 下一次迭代： 输入：[abcde] ^^^ 123 输出：cde

#包括
#包括
#包括
#包括
int main（）
{
char buf[6]=“abcde”；
int len=strlen（buf）；
//std：：向量字符列表；
对于（int i=0；i我希望可以做得更好，但这是我可以很快想到的

我使用了一个
列表
来保持秩序，不得不笨拙地避免重复。相反，使用
集合
将允许我们跳过
结果。包含检查，但更好的算法可能会以更干净的方式避免重复

private static List<String> substrings(int i, String input) {
    List<String> result = new ArrayList<String>();
    if (i == 0)
        return result;

    String first = input.substring(0, i);
    result.add(first);

    if (input.length() == i) {
        return result;
    }

    // Recursively find substrings of next smaller length not including the first character
    List<String> tails = substrings(i-1, input.substring(1));

    // Append first char to each result of the recursive call.
    for (String sub: tails) {
        String s = input.substring(0, 1) + sub;
        if (!(result.contains(s)))
            result.add(s);
    }

    // Add all substring of current length not including first character
    result.addAll(substrings(i, input.substring(1)));
    return result;
}

私有静态列表子字符串（int i，字符串输入）{
列表结果=新建ArrayList（）；
如果（i==0）
返回结果；
String first=input.substring（0，i）；
结果。添加（第一）；
if（input.length（）==i）{
返回结果；
}
//递归地查找不包括第一个字符的下一个较小长度的子字符串
列表尾=子字符串（i-1，输入子字符串（1））；
//向递归调用的每个结果追加第一个字符。
用于（字符串子：尾部）{
字符串s=input.substring（0，1）+sub；
如果（！（result.contains）））
结果。添加（s）；
}
//添加当前长度的所有子字符串，不包括第一个字符
result.addAll（子字符串（i，input.substring（1））；
返回结果；
}
您作为示例提供的每个组合都是按顺序排列的。这是一个要求吗？如果是，请在您的问题中说明：生成的字符串必须包含与原始字符串相同顺序的字符。该要求不适用于特定长度3。这只是一个示例。组合的长度可以根据不同的兴趣而变化假设函数是Combi（字符串原始，int-SizeOfCombination）。将问题分解为尽可能小的单元的子问题，然后尝试解决它会更容易。3应该很容易处理。组合可以是任意长度。长度3只是一个示例。如果我需要长度10的组合，则很难维护10个索引。@shrey347 Dynamic allocated array，C++向量等。总是可解的。：）这显示了比指定的要多得多。你可能想看看问题中的澄清。哦，对不起，代码错误，我更改了源代码…感谢你的回答。它似乎是正确的。你能给我解释
for
循环条件：
for（String substring:substring（i-1，input.substring（1）））
。虽然没有给出错误，但它似乎不是“Java”。这是一个“增强的for循环”，使用方法调用的结果作为遍历的列表。我将在代码中添加一个变量和一些注释，使其更清晰一点……非常感谢！这真的让我高兴。
private static List<String> substrings(int i, String input) {
    List<String> result = new ArrayList<String>();
    if (i == 0)
        return result;

    String first = input.substring(0, i);
    result.add(first);

    if (input.length() == i) {
        return result;
    }

    // Recursively find substrings of next smaller length not including the first character
    List<String> tails = substrings(i-1, input.substring(1));

    // Append first char to each result of the recursive call.
    for (String sub: tails) {
        String s = input.substring(0, 1) + sub;
        if (!(result.contains(s)))
            result.add(s);
    }

    // Add all substring of current length not including first character
    result.addAll(substrings(i, input.substring(1)));
    return result;
}