Java使用递归void函数的结果，将每个结果添加到列表中，并在另一个函数中返回

我正在使用我偶然发现的递归算法的修改版本来返回一组数据的所有组合。例如：如果数据集恰好是[“ABCD”、“ACDEF”、“ABDFG”、“BDEF”、“CGEGD”]，我希望列表中包含以下内容，即每个唯一元素都与另一个指定长度的唯一元素组合

A B C，A B D，A B E，A B F，A B G，A C D，A C F，A D G，A D F，A E G，A F G，B C D，B C E，B C F，B C G，B C F，B C G，B D E，B D F，B D G，B D D G，B D G，B D G，B D F，B F G，C D D G，C D F，C E F，C E F，C E，G，C F，D F，D F，G，F，E，F，F，G

以下是我目前的课程：

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

class Comboo {

    public static void combinationAssShit(String arr[], String data[], int start, int end, int index, int r){

    if (index == r)
     {
         for (int j=0; j<r; j++)
             System.out.print(data[j]+" ");

         System.out.println("");
         return;
     }

     for (int i=start; i<=end && end-i >= r-index; i++)
     {
         data[index] = arr[i];
         combinationAssShit(arr, data, i+1, end, index+1, r);
     }
 }

    public static void printCombination(String arr[], int n, int r)
    {
        String data[]=new String[r]; 
        combinationAssShit(arr, data, 0, n, 0, r);
    }

    public static String[] singleElem(String[] data) {
        List<String> single = new ArrayList<String>(); 

        for (String element: data) {
            for (int x = 0; x < element.length(); x++) {
                single.add(Character.toString(element.charAt(x)));
            }
        }

        Set<String> singleS = new LinkedHashSet<String>(single); 

        List<String> singleL = new ArrayList<String>(); 

        singleL.addAll(singleS); 

        String[] john = singleL.toArray(new String[singleL.size()]);
        return john;
    }

    public static void main (String[] args) {
        String arr[] = {"ABCD", "ACDEF", "ABDFG", "BDEF", "CGEGD"};
        int r = 3;

        String[] t = singleElem(arr);
        int n = t.length;
        printCombination(t, n, r);
    }
}

import java.util.ArrayList；
导入java.util.LinkedHashSet；
导入java.util.List；
导入java.util.Set；
类Combo{
公共静态无效组合ASSHOT（字符串arr[]，字符串数据[]，int start，int end，int index，int r）{
如果（索引==r）
{
对于（int j=0；j如果您想要返回最终结果（string），那么您可以将递归过程中的所有代码抛出到另一个helper方法中，并让初始方法调用helper并返回结果。
当然，为了通过return传递结果，您还需要使递归帮助程序和方法都不为空。
如果您想返回最终结果（字符串），您可以将递归过程中的所有代码抛出到另一个帮助程序方法中，并让初始方法调用帮助程序并返回结果。
当然，为了通过return传递结果，您还需要使递归助手和方法都不无效。
将方法的返回类型更改为
列表，并向列表中添加值：

public static List<String> combinationAssShit(String arr[], String data[], int start, int end, int index, int r){
  List<String> result = new ArrayList<>();
  if (index == r) {
    StringBuilder sb = new StringBuilder();
    for (int j=0; j<r; j++) {
      sb.append(data[j]);
      sb.append(" ");
    }
    result.add(sb.toString());
  } else {
    for (int i=start; i<=end && end-i >= r-index; i++)
    {
      data[index] = arr[i];
      result.addAll(combinationAssShit(arr, data, i+1, end, index+1, r));
    }
  }
  return result;
}

公共静态列表组合ASSHOT（字符串arr[]，字符串data[]，int start，int end，int index，int r）{
列表结果=新建ArrayList（）；
如果（索引==r）{
StringBuilder sb=新的StringBuilder（）；
对于（int j=0；j将方法的返回类型更改为
List
，并向列表中添加值：

public static List<String> combinationAssShit(String arr[], String data[], int start, int end, int index, int r){
  List<String> result = new ArrayList<>();
  if (index == r) {
    StringBuilder sb = new StringBuilder();
    for (int j=0; j<r; j++) {
      sb.append(data[j]);
      sb.append(" ");
    }
    result.add(sb.toString());
  } else {
    for (int i=start; i<=end && end-i >= r-index; i++)
    {
      data[index] = arr[i];
      result.addAll(combinationAssShit(arr, data, i+1, end, index+1, r));
    }
  }
  return result;
}

公共静态列表组合ASSHOT（字符串arr[]，字符串data[]，int start，int end，int index，int r）{
列表结果=新建ArrayList（）；
如果（索引==r）{
StringBuilder sb=新的StringBuilder（）；
对于（int j=0；jt）这里没有void函数的结果。这是void的定义。您需要返回实际值（例如字符串）才能在其他地方使用它。我理解，这是这里的紧迫问题。有关于如何在递归循环中返回字符串的提示吗？“我习惯了C++和Python，在这个问题上，通过从组合生成器中得到结果，在列表中收集组合要容易得多。”我很想知道你的意思。在组合SuthSIT（N，R-1）中，你应该能够在Java.for做同样的事情。是：java，肯定没有“<代码>收益率<代码> >，我不确定<代码>返回< /C> >是否在这里替换为“替换”。也就是说，C++也没有<代码>收益> /Cuff>，那么C++中如何实现它？没有空隙函数的结果。是void的定义。您需要返回一个实际值（例如字符串）才能在其他地方使用它。我理解，这是这里的紧迫问题。有关于如何在递归循环中返回字符串的提示吗？”我习惯C++和Python，在这个问题的情况下，通过从组合生成器中得到结果，在列表中收集组合要容易得多。“我很想知道你的意思。你应该能够在组合Java.for中做同样的事情（N，R-1）。是：java，肯定没有“<代码>收益率<代码> >，我不确定<代码>返回< /C> >是否在这里替换为“替换”。也就是说，C++也没有<代码>收益率>代码>，那么C++中如何实现它？…您可以将列表作为参数添加到方法中…”我认为在递归编程中，这有时被称为“累加器”变量。“…您可以将列表作为参数添加到方法中…”我认为在递归编程中，这有时被称为“累加器”变量。