java回型数组【思路清晰版】

代码【解析向下翻】

    /**
     * 回型数
     */
    public static void test5( ) {
        int[][] ints = numberOfRounds(10);
        for (int[] anInt : ints) {
            for (int i : anInt) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
        System.out.println("\n");
    }

    public static int[][] numberOfRounds(int length) {
        if (length < 0) {
            throw new RuntimeException("参数extent不能<0");
        }
        int index = 1;//用于给数组赋值
        int rightLength = length - 1;    //数组右边界限定值
        int bottomLength = length - 1;   //数组下边界限定值
        int leftLength = 0;     //数组左边界限定值
        int topLength = 0;      //数组上边界限定值

        //创建一个指定容量的二维数组
        int[][] arr = new int[length][length];
        //如果左边界<=右边界就执行循环体
        while (leftLength <= rightLength) {
            //上边赋值：从左边界开始，右边界结束，并且上边界加一
            for (int i = leftLength; i <= rightLength; i++) {
                arr[topLength][i] = index++;
            }
            topLength++;    //上边界加一
            //右边赋值：从上边界开始，下边界结束，并且右边界减一
            for (int j = topLength; j <= bottomLength; j++) {
                arr[j][rightLength] = index++;
            }
            rightLength--;
            //下别赋值：从右边界开始，下边界结束，并且下边界减一
            for (int i = rightLength; i >= leftLength; i--) {
                arr[bottomLength][i] = index++;
            }
            bottomLength--;
            //左边赋值：从下边界开始，上边界结束，并且左边界加一
            for (int j = bottomLength; j >= topLength; j--) {
                arr[j][leftLength] = index++;
            }
            leftLength++;
        }
        return arr;
    }

1.什么是回型数组：

 回型数组就是一个二维数组，包含的元素有一个回字型规律，

 2.分析：

赋值规律：arr[0][0]开始为数组的所有元素，

        第一次赋值

                给数组最上边赋值，

                给数组最右别赋值，

                给数组最下边赋值，

                该数组最左边赋值

为此我们需要准备4个边界以及赋值的初始值index，并且创建数组

        int index;          //用于给数组赋值
        int rightLength;    //数组右边界限定值
        int bottomLength;   //数组下边界限定值
        int leftLength;     //数组左边界限定值
        int topLength;      //数组上边界限定值

        //创建一个指定容量的二维数组
        int[][] arr = new int[length][length];

尝试赋值：

        为上边赋值：

            //上边赋值：从左边界开始，右边界结束，并且上边界加一
            for (int i = leftLength; i <= rightLength; i++) {
                arr[topLength][i] = index++;
            }
            topLength++;    //上边界加一

        为右边赋值：

            //右边赋值：从上边界开始，下边界结束，并且右边界减一
            for (int j = topLength; j <= bottomLength; j++) {
                arr[j][rightLength] = index++;
            }
            rightLength--;

        为下边赋值：

            //下别赋值：从右边界开始，下边界结束，并且下边界减一
            for (int i = rightLength; i >= leftLength; i--) {
                arr[bottomLength][i] = index++;
            }
            bottomLength--;

        为左边赋值：

            //左边赋值：从下边界开始，上边界结束，并且左边界加一
            for (int j = bottomLength; j >= topLength; j--) {
                arr[j][leftLength] = index++;
            }
            leftLength++;

到此我们已经为数组的边框赋值了

剩下的内容只需加一个循环即可

循环条件【左边界<=右边界】 

    public static int[][] numberOfRounds(int length) {
        if (length < 0) {
            throw new RuntimeException("参数extent不能<0");
        }
        int index = 1;//用于给数组赋值
        int rightLength = length - 1;    //数组右边界限定值
        int bottomLength = length - 1;   //数组下边界限定值
        int leftLength = 0;     //数组左边界限定值
        int topLength = 0;      //数组上边界限定值

        //创建一个指定容量的二维数组
        int[][] arr = new int[length][length];
        //如果左边界<=右边界就执行循环体
        while (leftLength <= rightLength) {
            //上边赋值：从左边界开始，右边界结束，并且上边界加一
            for (int i = leftLength; i <= rightLength; i++) {
                arr[topLength][i] = index++;
            }
            topLength++;    //上边界加一
            //右边赋值：从上边界开始，下边界结束，并且右边界减一
            for (int j = topLength; j <= bottomLength; j++) {
                arr[j][rightLength] = index++;
            }
            rightLength--;
            //下别赋值：从右边界开始，下边界结束，并且下边界减一
            for (int i = rightLength; i >= leftLength; i--) {
                arr[bottomLength][i] = index++;
            }
            bottomLength--;
            //左边赋值：从下边界开始，上边界结束，并且左边界加一
            for (int j = bottomLength; j >= topLength; j--) {
                arr[j][leftLength] = index++;
            }
            leftLength++;
        }
        return arr;
    }

运行结果：

 

四个循环分别为数组的上，右，下，左四个边赋值，可修改赋值的内容得到一些图案

 支持任意类型的回型数组

    /**
     * 回型数
     */
    public static void test5( ) {
        Object[][] ints = numberOfRounds(10);
        for (Object[] anInt : ints) {
            for (Object i : anInt) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
        System.out.println("\n");
    }

    public static Object[][] numberOfRounds(int length) {
        if (length < 0) {
            throw new RuntimeException("参数extent不能<0");
        }
        int index = 1;//用于给数组赋值
        int rightLength = length - 1;    //数组右边界限定值
        int bottomLength = length - 1;   //数组下边界限定值
        int leftLength = 0;     //数组左边界限定值
        int topLength = 0;      //数组上边界限定值

        //创建一个指定容量的二维数组
        Object[][] arr = new Object[length][length];
        //如果左边界<=右边界就执行循环体
        while (leftLength <= rightLength) {
            //上边赋值：从左边界开始，右边界结束，并且上边界加一
            for (int i = leftLength; i <= rightLength; i++) {
                arr[topLength][i] = index++;
            }
            topLength++;    //上边界加一
            //右边赋值：从上边界开始，下边界结束，并且右边界减一
            for (int j = topLength; j <= bottomLength; j++) {
                arr[j][rightLength] =index++;
            }
            rightLength--;
            //下别赋值：从右边界开始，下边界结束，并且下边界减一
            for (int i = rightLength; i >= leftLength; i--) {
                arr[bottomLength][i] = index++;
            }
            bottomLength--;
            //左边赋值：从下边界开始，上边界结束，并且左边界加一
            for (int j = bottomLength; j >= topLength; j--) {
                arr[j][leftLength] = index++;
            }
            leftLength++;
        }
        return arr;
    }