在Java中使用回溯递归打印字符串的所有子序列

我知道这是一个在这里被问了很多的问题，网上有很多例子，但我没有找到一个与我的问题相匹配的

---

我需要写一个代码，将接收一个字符串，并将打印所有不同的子序列的顺序，他们出现在字。解决方案应该只有递归方法，根本没有循环。 （显然，应该仅基于回溯递归和数组或子字符串）

例如，“012”应打印：“0”、“1”、“2”、“01”、“12”、“02”， “012”

起初，我打算做这样的事情：

public static void printSubs(String s) {
    printSubsSol(s, "");
}

private static void printSubsSol(String s, String temp) {
    if (s.length()==0) {
        System.out.print(temp+" ");
        return;
    }
    printSubsSol(s.substring(1), temp);
    printSubsSol(s.substring(1),temp+s.charAt(0));
}

印刷品：211200 02 01 012

我无法按正确的顺序打印所有的子序列，所以现在我尝试了一种使用字符数组的不同方法，这使我获得了一些成功，但我还没有做到

public class Ex9Q2V4 {
public static void printSubs(String s) {
    char[] tempArr = new char[s.length() - 1];
    printSubsSol(s, 0, 0, tempArr, 1);
    System.out.println('"' + s + '"');
}

private static boolean isSafe(int arrayIndex, int currentIndex, int howMuchToPrint, int length) {
    return (arrayIndex < howMuchToPrint && arrayIndex <= currentIndex && currentIndex < length);
}

private static void printSubsSol(String s, int arrayIndex, int currentIndex, char[] charArr, int howMuchToPrint) {
    if (howMuchToPrint == s.length()) {
        return;
    }
    charArr[arrayIndex] = s.charAt(currentIndex);
    if (arrayIndex == howMuchToPrint - 1) {
        System.out.print("\"");
        printArray(charArr, howMuchToPrint);
        System.out.print("\"" + ", ");
    }
    if (isSafe(arrayIndex + 1, currentIndex + 1, howMuchToPrint, s.length())) {
        printSubsSol(s, arrayIndex + 1, currentIndex + 1, charArr, howMuchToPrint);

    }
    else if (isSafe(arrayIndex, currentIndex + 1, howMuchToPrint, s.length())) {
        printSubsSol(s, arrayIndex, currentIndex + 1, charArr, howMuchToPrint);

    }
    else printSubsSol(s, 0, 0, charArr, howMuchToPrint + 1);
}

// A method that prints the array
private static void printArray(char arr[], int n) {
    if (n != 0) {
        printArray(arr, n - 1);
        System.out.print(arr[n - 1]);
    }
}

公共类Ex9Q2V4{
公共静态void printSubs（字符串s）{
char[]tempArr=新字符[s.length（）-1]；
printsubsol（s，0，0，tempArr，1）；
System.out.println（““+s+”）；
}
私有静态布尔isSafe（int arrayIndex、int currentIndex、int howMuchToPrint、int length）{
return（arrayIndex
for (int i = 1; i <= s.length(); i++) {
     for (int j = 0; j + i <= s.length(); j++) {
          System.out.print(s.substring(j, j + i) + " ");
     }
}

for（inti=1；i我在
C
在线找到了一个算法，并将其转换为
Java
和使用
字符串

我必须将这些值存储在
树集
中才能获得所需的顺序

这是怎么称呼它的

        String str = "0123";

        Set<String> set = new TreeSet<>(Comparator
                .comparing(String::length)
                .thenComparing(Comparator.naturalOrder()));

        subseq(str, 0, "", set);

        set.forEach(System.out::println);

String str=“0123”；
设置=新树集（比较器
.比较（字符串：：长度）
.然后比较（Comparator.naturalOrder（））；
子类（str，0，“，set）；
set.forEach（System.out:：println）；

这是修改后的算法


    static void subseq(String arr, int index, String subarr,
            Set<String> set) {
        if (index == arr.length()) {
            int l = subarr.length();
            if (l != 0) {
                set.add(subarr.substring(0, l));
            }
        } else {
            subseq(arr, index + 1, subarr, set);
            subarr = subarr
                    + arr.substring(index, index + 1);
            subseq(arr, index + 1, subarr, set);
        }
        return;
    }


静态void subseq（字符串arr、整数索引、字符串subar、，
（一套）{
如果（索引==arr.length（））{
int l=子长度（）；
如果（l！=0）{
set.add（子串（0，l））；
}
}否则{
子类（arr，索引+1，子类，集合）；
斯巴鲁=斯巴鲁
+arr.substring（索引，索引+1）；
子类（arr，索引+1，子类，集合）；
}
返回；
}
谢谢，但您的解决方案不会打印“02”。它只会打印相邻的字符。您是对的，我没有足够注意，您能告诉我“0123”应该打印什么，以便我可以编辑我的答案吗？“0”、“1”、“2”、“3”、“01”、“12”、“23”、“02”、“03”、“13”、“012”、“123”，“023”，“013”，“0123”谢谢，但与前面的答案相同，您的解决方案不会打印“02”。它只会打印相邻的字符。起初我也用铅笔和纸开始，后来我才开始编写代码，但即使在纸上，我也无法思考按照这种特定顺序执行该操作的正确算法。你说得对！我已修复了它。但我必须将值添加到
树集
，以获得顺序。然后请再说一遍，但我不应该使用Tree的，所以我会等待更多的回答。你应该更新你的答案，并明确说明你可以使用什么和不可以使用什么。否则，人们只会猜测。你从来没有说过你不能使用集合。我可以使用集合，但我知道我不应该使用它。所以我想看看其他解决方案s、 问题中有一点是明确的，那就是循环，我会记住它，但我会编辑它。不管怎样，我会再次编辑它

    static void subseq(String arr, int index, String subarr,
            Set<String> set) {
        if (index == arr.length()) {
            int l = subarr.length();
            if (l != 0) {
                set.add(subarr.substring(0, l));
            }
        } else {
            subseq(arr, index + 1, subarr, set);
            subarr = subarr
                    + arr.substring(index, index + 1);
            subseq(arr, index + 1, subarr, set);
        }
        return;
    }