通过递归实现嵌套未知次数的循环

2024年6月1日 54次阅读

如下示例：

public class Test4 {

    public static void main(String[] args) {

        int m = 10;
        int n = 9;
        int p = 4;
        int q = 7;

        for(int i=0;i<m;i++){
            int a = i;
            for(int j=0;j<n;j++){
                int b = j;
                if(b==a){
                    continue;
                }
                for(int k=0;k<p;k++){
                    int c = k;
                    if(c==b || c==a){
                        continue;
                    }
                    for(int l=0;l<q;l++){
                        int d = l;
                        if(d==c || d==b || d==a){
                            continue;
                        }
                        System.out.println("["+i+", "+j+", "+k+", "+l+"]");
                    }
                }
            }
        }

    }

}

如果嵌套循环个数是动态指定的，那么，通过上面的方式就无法实现了，以上的方式只能在确定嵌套循环的个数的情况下奏效。

怎么破，使用递归可以巧妙解决上述的场景,代码如下：

import java.util.Arrays;

public class Test5{

    public static void main(String[] args) {
        recurse(new int[] {5, 2, 4}, new int[3], 0);
    }


    public static void recurse(int[] a, int[] b, int depth) {
        if (depth == a.length) {
            System.out.println(Arrays.toString(b));
            return;
        }

        outer:
        for (int i = 0; i < a[depth]; i++) {
            for (int j = 0; j < depth; j++) {
                if (i == b[j]) {
                    continue outer;
                }
            }
            b[depth] = i;
            recurse(a, b, depth + 1);
        }
    }

}

对比一下可以看出：通过递归实现的代码非常简洁和优雅，但是效率也是很差的，尤其是当循环的次数和嵌套的深度都很大的话。

点赞