Rekursive Permutation mit mehreren Listen

Question

Ich bin gespannt, wie ich meine permuteAndPrintValuesThreeLists_Iterative Methode rekursiv durchführen kann ... Ich kenne grundlegende Rekursion zum Sortieren von Arrays und Ausführen von binären Suchen, aber ich kann nicht herausfinden, wie es meine Methode rekursiv machen.

Der Grund, warum ich Rekursion verwenden möchte, ist, weil ich die Möglichkeit haben möchte, mehr als 3 Listen hinzuzufügen, ohne meine Methode zu ändern, indem ich eine weitere for-Schleife hinzufüge.

Frage: Wie schreibe ich permuteAndPrintValuesThreeLists Methode als recursive Methode?

Meine Ausgabe sollte sein:

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 

Aber es ist:

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 + " "); 
    } 
    } 

} 

Bisher wusste ich, ich brauche eine Liste zu haben, die die 3-Listen enthält (in In meinem Fall habe ich eine HashMap hinzugefügt. Ich habe auch diese Lösung Methode, die teilweise das 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

Durch das Hinzufügen eines Try-Catch-Block löst, bekam ich die Ausgabe, die ich in meiner Frage gedruckt. Ich verwende set, um die neuen Werte für die Permutation hinzuzufügen.

Jetzt, wenn ich eine vierte Liste möchte, funktioniert diese Methode noch.

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(); 
}