Java 使用递归查找长度为k的所有可能字符串

对于字符串s=“abcd”，k=3，则答案应为：

abc
abd
acd
bcd

java递归代码（k=3）：

公共类子字符串{
静态ArrayList al=新ArrayList（）；
公共静态void main（字符串[]args）{
字符串s=“abcd”；
findsubsequences（“”；//调用函数
for（字符串子字符串：al）{
if（subString.length（）==3）{
System.out.println（子字符串）；
}
}
}
公共静态void findsubsequences（字符串s、字符串ans）{
如果（s.length（）==0）{
al.add（ans）；
返回；
}
查找子序列（s.substring（1），ans+s.charAt（0））；
查找子序列（s.子串（1），ans）；
}
}

---

我想通过递归以最快的方式找到长度为k的所有可能的子字符串，而不使用arraylist中的foreach

更快/更干净的解决方案是在达到最大长度时停止迭代。只有长度正确时，才应添加元素：

public static void findsubsequences(String s, String ans, int maxLength) {
    if (s.length() == 0) {
        return;
    }
    if (ans.length() == maxLength) {
        al.add(ans);
        return;
    }
    findsubsequences(s.substring(1), ans + s.charAt(0), maxLength);
    findsubsequences(s.substring(1), ans, maxLength);
}

此外，您还可以删除

静态
结果列表，而不是返回结果：

public static void main(String[] args) {
    String s = "abcdefgh";
    List<String> results = findSubsequences(s, "", 3);
    for (String subString : results) {
        System.out.println(subString);
    }
}

public static List<String> findSubsequences(String s, String ans, int maxLength) {
    if (s.length() == 0) {
        return new ArrayList<>();
    }
    if (ans.length() == maxLength) {
        return Collections.singletonList(ans);
    }

    List<String> list = new ArrayList<>(findSubsequences(s.substring(1), ans + s.charAt(0), maxLength));
    list.addAll(findSubsequences(s.substring(1), ans, maxLength));
    return list;
}

publicstaticvoidmain（字符串[]args）{
字符串s=“abcdefgh”；
列表结果=找到的子序列（s，“，3）；
for（字符串子字符串：结果）{
System.out.println（子字符串）；
}
}
公共静态列表查找子序列（字符串s、字符串ans、int maxLength）{
如果（s.length（）==0）{
返回新的ArrayList（）；
}
if（ans.length（）==maxLength）{
返回集合。单音列表（ans）；
}
列表列表=新的ArrayList（查找子序列（s.substring（1）、ans+s.charAt（0）、maxLength））；
addAll（findSubsequences（s.substring（1），ans，maxLength））；
退货清单；
}
试试这个

public static List<String> findsubsequences(String s, int k) {
    List<String> al = new ArrayList<>();
    new Object() {
        void find(int index, String ans) {
            if (index >= s.length()) {
                if (ans.length() == k)
                    al.add(ans);
                return;
            }
            find(index + 1, ans + s.charAt(index));
            find(index + 1, ans);
        }
    }.find(0, "");
    return al;
}

输出

[abc, abd, acd, bcd]

使用回溯逻辑的解决方案（可推广用于解决任何排列/子集/组合问题）-

问题是什么？代码不起作用吗？不够快/效率？我不想在main方法中使用foreach，我需要一个像findsubsequences（String s，int k）这样的方法来找到所有可能的长度为k的子串。然后你应该在
findsubsequences
中检查
ans
的长度，并在
ans
足够长时停止深入。你能帮我写具体的吗，抱歉，如果我的英语不好，如果你通过arraylist作为参数并对其进行变异，会更好。它可以大大降低成本allocations@JakubDóka是的，但如果你想走这种优化路线，我建议你无论如何都不要递归地去做。代码总体上看起来会更干净，我可以编辑吗？
findsubsequences（“abcd”），3）在列表中只存储
“abc”
。使用
temp.setLength（temp.length（）-1）代替
temp.setLength（temp.length（）-1）
更为明显。
System.out.println(findsubsequences("abcd", 3));

[abc, abd, acd, bcd]

public static void main(String[] args) {
    ans = new ArrayList<>();
    String s = "abcd";
    int k = 3;
    generatePermutation(new StringBuilder(""), 0, s.toCharArray(), k);
    System.out.println(ans);
}

private static List<String> ans;

private static void generatePermutation(StringBuilder temp, int st, char[] str, int k){
    if(temp.length() == k){
        // base result
        String br = temp.toString();
        ans.add(br);
        return;
    }
    
    for(int i = st; i < str.length; i++){
        temp.append(str[i]);
        generatePermutation(temp, i + 1, str, k);
        temp.setLength(temp.length() - 1);
    }
}

[abc, abd, acd, bcd]