具有多个列表的递归置换

Question

I'm curious how I can perform my permuteAndPrintValuesThreeLists_Iterative method recursively... I know basic recursion for sorting arrays and performing binary searches, but I can't figure out how to make it my method recursive.

The reason I want to use recursion, is because I want to have the possibility to add more than 3 lists, without changing my method by adding another for loop.

Question : How do I write permuteAndPrintValuesThreeLists method as a recursive method ?

My output should be:

1 1 10 10 100 100
1 1 10 10 200 200
1 1 10 10 300 300
1 1 20 20 100 100
1 1 20 20 200 200
1 1 20 20 300 300
2 2 10 10 100 100
2 2 10 10 200 200
2 2 10 10 300 300
2 2 20 20 100 100
2 2 20 20 200 200
2 2 20 20 300 300

But it is:

1 1 10 10 100 100 
200 200 
300 300 
400 400 
20 20 100 100 
200 200 
300 300 
400 400 
3 3 10 10 100 100 
200 200 
300 300 
400 400 
20 20 100 100 
200 200 
300 300 
400 400 

---

final class Problem {

  public static void main(String[] args) {
    Problem p = new Problem();
    p.permuteAndPrintValuesThreeLists_Iterative();
  }

  private static List<int[]> l1;
  private static List<int[]> l2;
  private static List<int[]> l3;

  private Problem() {
    l1 = new ArrayList<>();
    l1.add(new int[] { 1, 1 });
    l1.add(new int[] { 2, 2 });

    l2 = new ArrayList<>();
    l2.add(new int[] { 10, 10 });
    l2.add(new int[] { 20, 20 });

    l3 = new ArrayList<>();
    l3.add(new int[] { 100, 100 });
    l3.add(new int[] { 200, 200 });
    l3.add(new int[] { 300, 300 });
  }

  private static void permuteAndPrintValuesThreeLists_Iterative() {
    for (int i = 0; i < l1.size(); i++) {
      for (int j = 0; j < l2.size(); j++) {
        for (int k = 0; k < l3.size(); k++) {
          printArray(l1.get(i));
          printArray(l2.get(j));
          printArray(l3.get(k));
          System.out.println();
        }
      }
    }
  }

  private static void printArray(int[] a) {
    for (int i : a) {
      System.out.println(i + " ");
    }
  }

}

So far I knew I need to have a list that contains the 3 lists (in my case I added a HashMap). I also have this solution method that partially solves the problem

private static Map<Integer, List<int[]>> allLists = new HashMap<>();
private static void permuteAndPrintValuesThreeLists_Recursion(List<int[]> resultList, int mapIndex) {
    if (mapIndex == allLists.size()) {
        // Debug code
        for (int[] arr : resultList)
            for (int i = 0; i < arr.length; i++)
                System.out.println(arr[i] + " ");
        resultList.clear();
        System.out.println();
        return;
    }
    for (int i = 0; i < allLists.get(mapIndex).size(); i++) {
        int[] tmpArray = allLists.get(mapIndex).get(i);
        resultList.add(tmpArray);
        permuteAndPrintValuesThreeLists_Recursion(resultList, mapIndex + 1);
    }
}

Answer 1

By adding a try catch block, I got the output that I printed in my question. I use set to add the new values for the permutation.

Now if I want a fourth list, this method still works.

private static void solution_withRecursion(List<int[]> resultList, int mapIndex) {
    if (mapIndex == allLists.size()) {
        printListValues(resultList);
        return;
    }
    for (int i = 0; i < allLists.get(mapIndex).size(); i++) {
        int[] tmpArray = allLists.get(mapIndex).get(i);
        try {
            resultList.set(mapIndex, tmpArray);
        } catch (IndexOutOfBoundsException e) {
            resultList.add(tmpArray);
        }
        solution_withRecursion(resultList, mapIndex + 1);
    }
}


private static void printListValues(List<int[]> list) {
    for (int[] arr : list) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
    System.out.println();
}