Java 递归函数，以获取动态列表数的组合

我正试图编写一个递归函数，从动态列表数中获得所有可能的组合。例如，如果我有3个列表

List 1 : {A,B}
List 2 : {B,C}
List 3 : {D}

即使在输出中，每个元素只出现一次，我还是希望将输出保持在

List<List<List<elements>>>

在这里，列表的数量可以动态变化。所以我需要动态的嵌套循环数来找到组合

这就是我想要的。别理我那糟糕的代码

public List<List<List<elements>>> combinations(int depth, List<List<elements>> allLists,List<List<List<elements>>> answerList){

if(depth==allList.size())
 return answerList
 }
else{ 
 for(List<element> e : answerList){
    for(int j=0; j<e.size();j++){
      answerList.get(depth).get(j).add(allList.get(depth).get(j));
combinations (depth+1,allLists,answerList)
}
}
}

---

您需要一个非常常见的递归模式，在该模式中，您维护一个包含构建到当前级别的状态的变量。这里有一些代码给你

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

public class Main 
{
  public static void recurse(int depth,
                      List<List<String>> current,
                      List<List<List<String>>> result,
                      List<List<String>> lists)
  {
    if (depth == lists.size()) {
      // Copy the list to the result
      result.add(new ArrayList<List<String>>(current));
      return;
    }
    // Iterate over the current-depth list
    List<String> list = lists.get(depth);
    for (String str: list) {
      List<String> elem = Arrays.asList(str);
      current.add(elem);   // Add the next element to the list
      recurse(depth + 1, current, result, lists);
      current.remove(depth);  // Clean up this element
    }
  }

  public static List<List<List<String>>> combinations(List<List<String>> allLists) 
  {
      // We'll fill it in
      List<List<List<String>>> result = new ArrayList<>();

      // Current, partial row in the final result
      List<List<String>> current = new ArrayList<>();

      recurse(0, current, result, allLists);

      return result;
  }

  public static void main(String[] args) {

    System.out.println("Hello World!");

    List<String> list1 = Arrays.asList("A", "B");
    List<String> list2 = Arrays.asList("B", "C", "E");
    List<String> list3 = Arrays.asList("D", "X");

    List<List<String>> allLists = Arrays.asList(list1, list2, list3);

    List<List<List<String>>> result = combinations(allLists);

    // Print
    for (List<List<String>> list: result) {
      System.out.print("{ ");
      for (List<String> elem: list)
        System.out.print("{" + elem.get(0) + "} ");
      System.out.println("}");
    }
  }
}

导入java.util.array；
导入java.util.List；
导入java.util.ArrayList；
公共班机
{
公共静态无效递归（int-depth，
列出当前，
列出结果，
（列表）
{
if（depth==lists.size（））{
//将列表复制到结果
结果.添加（新ArrayList（当前））；
返回；
}
//迭代当前深度列表
List=lists.get（深度）；
for（字符串str:list）{
List elem=Arrays.asList（str）；
current.add（elem）；//将下一个元素添加到列表中
递归（深度+1、当前、结果、列表）；
current.remove（深度）；//清除此元素
}
}
公共静态列表组合（列表所有列表）
{
//我们会填的
列表结果=新建ArrayList（）；
//最终结果中的当前、部分行
当前列表=新的ArrayList（）；
递归（0，当前，结果，所有列表）；
返回结果；
}
公共静态void main（字符串[]args）{
System.out.println（“你好，世界！”）；
list1=Arrays.asList（“A”、“B”）；
list2=Arrays.asList（“B”、“C”、“E”）；
list3=Arrays.asList（“D”，“X”）；
List allLists=Arrays.asList（list1、list2、list3）；
列表结果=组合（所有列表）；
//印刷品
对于（列表：结果）{
系统输出打印（“{”）；
对于（列表元素：列表）
System.out.print（“{”+元素get（0）+”}”）；
System.out.println（“}”）；
}
}
}

---

顺便说一句，你可以在没有第三级列表的情况下简化它，如@dasblinkenlight建议的

有五个列表，你希望构建

列表

？你能检查一下这个问题吗：你能解释一下列表列表应该包含什么吗？理解所需的输出有点困难（如果您想在这个特定的结构中使用它）。列表的元素是什么？@dasblinkenlight我已经在问题中解释了我的结构。请检查我的编辑。“谢谢你！”真怀疑论者我已经在编辑中解释了我的结构。现在也考虑元素为字符串。

 {
   {
     {A},
     {B},
     {D}
   },
   {
     {A},
     {C},
     {D}
   },
   {
     {B},
     {B},
     {D}
   },
   {
     {B},
     {C},
     {D}
   }
 }

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

public class Main 
{
  public static void recurse(int depth,
                      List<List<String>> current,
                      List<List<List<String>>> result,
                      List<List<String>> lists)
  {
    if (depth == lists.size()) {
      // Copy the list to the result
      result.add(new ArrayList<List<String>>(current));
      return;
    }
    // Iterate over the current-depth list
    List<String> list = lists.get(depth);
    for (String str: list) {
      List<String> elem = Arrays.asList(str);
      current.add(elem);   // Add the next element to the list
      recurse(depth + 1, current, result, lists);
      current.remove(depth);  // Clean up this element
    }
  }

  public static List<List<List<String>>> combinations(List<List<String>> allLists) 
  {
      // We'll fill it in
      List<List<List<String>>> result = new ArrayList<>();

      // Current, partial row in the final result
      List<List<String>> current = new ArrayList<>();

      recurse(0, current, result, allLists);

      return result;
  }

  public static void main(String[] args) {

    System.out.println("Hello World!");

    List<String> list1 = Arrays.asList("A", "B");
    List<String> list2 = Arrays.asList("B", "C", "E");
    List<String> list3 = Arrays.asList("D", "X");

    List<List<String>> allLists = Arrays.asList(list1, list2, list3);

    List<List<List<String>>> result = combinations(allLists);

    // Print
    for (List<List<String>> list: result) {
      System.out.print("{ ");
      for (List<String> elem: list)
        System.out.print("{" + elem.get(0) + "} ");
      System.out.println("}");
    }
  }
}