CODEWITHSUNDEEP
javaalgorithmloopsfor-loop
JackWM
JackWM

Reputation: 10555

How to dynamically control the for-loop nested level?

I am implementing some algorithm, in which the number of loop nested levels is determined by the input.

For example, if the input is 2-dimensional, then there two nested for-loops, as below:

for(int i=0; i<N; i++) {
    for(int j=i+1; j<N; j++) {
        if(table[i][j] == -1) {
            for(int c=0; c<C; c++) {
                int ii = table[i][c];
                int jj = table[j][c];
                sort(ii, jj);
                if((T[ii][jj] != -1 && T[ii][jj] < l)) {
                    T[i][j] = l;
                    break;
                }
             }
         }
     }
}

If the input is 3-dimensional, then it would be something like below:

for(int i=0; i<N; i++) {
    for(int j=i+1; j<N; j++) {
        for(int k=j+1; k<N; k++) {
            if(table[i][j][k] == -1) {
                for(int c=0; c<C; c++) {
                    int ii = table[i][c];
                    int jj = table[j][c];
                    int kk = table[k][c];
                    sort(ii, jj, kk);
                    if((T[ii][jj][kk] != -1 && T[ii][jj][kk] < l)) {
                        T[i][j][k] = l;
                        break;
                    }
                }
           }
      }
}

If there are only these two case, then I can write two versions of nested for-loops. But the dimensions of input could be any value between 2 and N. In this case, how to control the nested loop level dynamically, or is there any alternative to go around of this?

Upvotes: 1

Views: 241

Answers (4)

Martijn Courteaux
Martijn Courteaux

Reputation: 68887

Recursion is already been explained here. However, there is another solution as well. Using only one big loop containing a tiny inner loop.

int n = ...;
int dim = ...;

// Raise n to the power of dim: powN = n^dim
long powN = 1;
for (int i = 0; i < dim; ++i) powN *= n;

int[] indices = new int[dim];
for (long i = 0; i < powN; ++i)
{
    // Calculate the indices
    long bigI = i;
    for (int k = 0; k < dim; ++k)
    {
         indices[k] = bigI % n;
         bigI /= n;
    }

    // Now all your indices are stored in indices[]

}

Upvotes: 1

NiiL
NiiL

Reputation: 2827

You may explain what you really want to do.

If the Outer for loops are doing nothing but controlling a count, then your Nested for loops are simply a more complicated way of iterating by a count that could be handled by a Single for loop.

like:

for (x = 0; x < 8; x++) {
  for (y = 0; y < 10; y++) {
    for (z = 0; z < 5; z++) {
      DoYourStuffs();
    }
  }
}

Is equivalent to:

for (x = 0; x < 8*10*5; x++) {
  DoYourStuffs();
}

Upvotes: 0

Wajahat
Wajahat

Reputation: 1633

I was suggesting something like this : 

public static void recursiveLoop(int N, int level, int a){
     if (level<0)
        return;
     for (int i=a; i<N; i++){
         System.out.println("Level is : "+ level+ " i: "+i );
         recursiveLoop(N,level-1,i+1);
     }
 }

Upvotes: 0

Tim B
Tim B

Reputation: 41208

The only real way to do this is to use recursion.

You write a method containing a single for loop, each time around the loop if it needs to go deeper then the method calls itself with the right settings for that nested loop to be run.

Upvotes: 3

Related Questions