八皇后问题，为什么要使用递归，循环转递归的思考过程（Java日记Ⅷ）

说明：

本篇旨在说明怎么想到使用递归，所使用的算法是最垃圾的也是最浅显易懂的（从零到七疯狂试探，没有任何优化），我最开始是想使用循环解决这个问题，但是并没有找到什么特别好的方法，只能一层一层套for循环，这个时候我其实就想到递归了，但为了能清晰的展现思路，我还是硬着头皮把它写出来了，这样更方便观察，能够让我们在把它转化成递归的时候让思路能够清晰直观，不至于不知道从何处下手。八皇后问题其实就是一个排列组合的问题，明白这一点后其实能减少许多不必要的试探，如果想看优化之后的递归代码请看下一篇Java日记Ⅸ。

代码以及说明如下：

public class QueenDemo {
    public static void main(String[] args) {

        int[] arr=new int[9];
        int[] arr2=new int[8];
        get(arr,8);//递归方法，数组多出一个位置存结果
        int count=getCount(arr2);//循环方法，直接返回结果
        System.out.println(count);
        System.out.println(arr[8]);

    }
    public static int getCount(int[] arr){
        int count=0;
        int all=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                for (int k = 0; k < arr.length; k++) {
                    for (int l = 0; l < arr.length; l++) {
                        for (int m = 0; m < arr.length; m++) {
                            for (int n = 0; n <arr.length ; n++) {
                                for (int o = 0; o < arr.length; o++) {
                                    for (int p = 0; p < arr.length; p++) {
                                        arr[0]=i;
                                        arr[1]=j;
                                        arr[2]=k;
                                        arr[3]=l;
                                        arr[4]=m;
                                        arr[5]=n;
                                        arr[6]=o;
                                        arr[7]=p;
                                        if(jud(arr)){
                                            count++;
                                        }
                                        all++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return count;
    }
    public static void get(int[] arr,int max){
        for (int i = 0; i < arr.length-1; i++) {
            arr[max-1]=i;
            if(max==1){
                if(judge(arr)){
                    arr[arr.length-1]++;
                }
            }
            else {
                get(arr,--max);
                max++;//max一定要还原切记，这里也卡了我半天
            }
        }
    }
    //因为使用的数组长度不同，为了方便你们看懂我就写了两个，之前因为忘了两个数组长度不同用一个judge害的我卡了半天也没想出哪里出了问题
    public static boolean jud(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = arr.length-1; j >i; j--) {
                if(arr[i]==arr[j]||Math.abs(i-j)==Math.abs(arr[i]-arr[j])){
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean judge(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = arr.length-2; j >i; j--) {
                if(arr[i]==arr[j]||Math.abs(i-j)==Math.abs(arr[i]-arr[j])){
                    return false;
                }
            }
        }
        return true;
    }
}