fonction récursive en java - N boucles imbriquées avec indicies changeantes

Question

similaires à ceci: Is there any way to do n-level nested loops in Java?

Je veux créer une fonction récursive, qui génère N boucles imbriquées, où les indicies dépendent de la profondeur de la boucle. Donc, fondamentalement, je veux faire récursive:

// N = 3, so we want three nested loops 

for(int i1 = 0; i1 < max; i1++){ 
    for(int i2 = i1+1; i2 < max; i2++){ 
     for(int i3 = i2+1; i3 < max; i3++){ 
      int value1 = getValue(i1); 
      int value2 = getValue(i2); 
      int value3 = getValue(i3); 
      doSomethingWithTheValues(...); 
     } 
    } 
} 

J'ai regardé les réponses à l'autre question, et a essayé de modifier la réponse (par oel.neely), mais sans chance. Ma conjecture est qu'il a seulement besoin d'une petite modification, mais en ce moment, je suis juste confus moi-même!

Answer 1

Son C#, mais devrait être facilement à Java convertable:

class ImmutableStack<T> 
{ 
    public readonly T Head; 
    public readonly ImmutableStack<T> Tail; 

    public ImmutableStack(T head, ImmutableStack<T> tail) 
    { 
     this.Head = head; 
     this.Tail = tail; 
    } 

    public static ImmutableStack<T> Cons(T head, ImmutableStack<T> tail) 
    { 
     return new ImmutableStack<T>(head, tail); 
    } 

    public static ImmutableStack<T> Reverse(ImmutableStack<T> s) 
    { 
     ImmutableStack<T> res = null; 
     while (s != null) 
     { 
      res = Cons(s.Head, res); 
      s = s.Tail; 
     } 
     return res; 
    } 
} 

class Program 
{ 
    static void AwesomeRecursion(int toDepth, int start, int max, ImmutableStack<int> indices) 
    { 
     if (toDepth < 0) 
     { 
      throw new ArgumentException("toDepth should be >= 0"); 
     } 
     else if (toDepth == 0) 
     { 
      Console.Write("indices: "); 
      indices = ImmutableStack<int>.Reverse(indices); 
      while (indices != null) 
      { 
       Console.Write("{0}, ", indices.Head); 
       indices = indices.Tail; 
      } 
      Console.WriteLine(); 
     } 
     else 
     { 
      for (int i = start; i < max; i++) 
      { 
       AwesomeRecursion(toDepth - 1, i + 1, max, ImmutableStack<int>.Cons(i, indices)); 
      } 
     } 
    } 


    static void Main(string[] args) 
    { 
     AwesomeRecursion(4, 1, 10, null); 
     Console.WriteLine("Done"); 
     Console.ReadKey(true); 
    } 
} 

Nous gardons les indices sur une pile immuable car il fait marche arrière tellement plus facile que les piles mutables ou les files d'attente.