Variable Anzahl von for-Schleifen ohne Rekursion aber mit Stack?

Question

Ich weiß, der übliche Ansatz für "variable Anzahl von for Schleifen" soll eine rekursive Methode verwenden. Aber ich frage mich, ob ich das ohne Rekursion lösen könnte und stattdessen mit Stack, da Sie Rekursion mit der Verwendung eines Stapels umgehen können.

Mein Beispiel:
Ich habe eine variable Anzahl von Sammlungen und ich brauche jedes Element jeder Kollektion mit jedem anderen Punkt der anderen Sammlungen zu kombinieren.

// example for collections A, B and C: 
A (4 items) + B (8 items) + C (10 items) 
4 * 8 * 10 = 320 combinations 

Ich muss alle diese 320 Kombinationen durchlaufen. Zur Kompilierzeit weiß ich nicht, ob B oder C oder D existieren. Wie würde eine Lösung ohne rekursive Methode, aber mit der Verwendung einer Instanz von Stack aussehen?

Edit:
Ich erkennen Stapel nicht notwendig ist, hier überhaupt, während Sie die Rekursion mit einem einfachen int-Array und ein paar While-Schleifen zu vermeiden. Danke für Hilfe und Info.

Answer 1

Hier ist ein Beispiel dafür, wie dies zu tun. Der Algorithmus wird aus dieser Frage - https://stackoverflow.com/a/2419399/5311735 - entnommen und in C# umgewandelt. Beachten Sie, dass es effizienter gemacht werden kann, aber ich umgewandelt ineffizient Version C#, weil es besser ist das Konzept zeigt (Sie effizientere Version in der verknüpften Frage sehen):

static IEnumerable<T[]> CartesianProduct<T>(IList<IList<T>> collections) { 
     // this contains the indexes of elements from each collection to combine next 
     var indexes = new int[collections.Count]; 
     bool done = false; 
     while (!done) { 
      // initialize array for next combination 
      var nextProduct = new T[collections.Count]; 
      // fill it 
      for (int i = 0; i < collections.Count; i++) { 
       var collection = collections[i]; 
       nextProduct[i] = collection[indexes[i]]; 
      } 
      yield return nextProduct; 
      // now we need to calculate indexes for the next combination 
      // for that, increase last index by one, until it becomes equal to the length of last collection 
      // then increase second last index by one until it becomes equal to the length of second last collection 
      // and so on - basically the same how you would do with regular numbers - 09 + 1 = 10, 099 + 1 = 100 and so on. 

      var j = collections.Count - 1; 
      while (true) { 
       indexes[j]++; 
       if (indexes[j] < collections[j].Count) { 
        break; 
       } 
       indexes[j] = 0; 
       j--; 
       if (j < 0) { 
        done = true; 
        break; 
       } 
      } 
     } 
    } 

Answer 2

Nicht mit einem Stapel, aber ohne Rekursion.

void Main() 
{ 
    var l = new List<List<int>>() 
    { 
     new List<int>(){ 1,2,3 }, 
     new List<int>(){ 4,5,6 }, 
     new List<int>(){ 7,8,9 } 
    }; 

    var result = CartesianProduct(l); 
} 

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences) 
{ 
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>()}; 
    return sequences.Aggregate(
     emptyProduct, 
     (accumulator, sequence) => 
      from accseq in accumulator 
      from item in sequence 
      select accseq.Concat(new[] {item})      
     ); 
} 

Funktion genommen Form Computing a Cartesian Product with LINQ