算法导论：打印回旋数

　　问题：打印输出逆时针螺旋矩阵，要求螺旋矩阵的阶数由用户输入。例如 n=4时，输出的螺旋矩阵如下：

　　

　　下面给出我的代码：　　

package org.warnier.zhang.exercises;

public class Convolution {
    private int n;
    private int[][] array;
    private int number = 1;

    public Convolution(int n) {
        this.n = n;
        array = new int[n][n];
        init();
    }

    private void init() {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                array[i][j] = 0;
            }
        }
    }

    //逆时针方向回旋；
    public void generateConvolutionNumber() {
        //处理迭代“内圈”数字输出；
        int a = 0;
        int b = n -1 - a;
        while (b >= a) {
            //与正常的数组输出方向一致螺旋输出；
            for (int i = a; i <= b; i++) {
                for (int j = a; j <= b; j++) {
                    if (i != b && j == a) {
                        array[i][j] = number++;
                    }
                    if (i == b && j != b) {
                        array[i][j] = number++;
                    }
                }
            }
            
            //与正常的数组输出方向相反螺旋输出；
            for (int i = b; i >= a; i--) {
                for (int j = b; j >= a; j--) {
                    if (i != a && j == b) {
                        array[i][j] = number++;
                    }
                    if (i == a && j != a) {
                        array[i][j] = number++;
                    }
                }
            }
            
            a ++;
            b = n -1 - a;
        }
        
        //打个补丁：没能解决n为奇数的情况！（没有加上这句代码，中间的空格输出默认值0！）
        if(n % 2 != 0){
            array[n/2][n/2] = number;
        }
    }

    public void vprintf() {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.printf("%3d", array[i][j]);
            }
            System.out.println();
        }
    }

}

　　简要说明，a 和 b 的存在，是为了解决螺旋输出内圈的数字；下面的是测试代码：

package org.warnier.zhang.exercises;

public class ConvolutionTest {

    public static void main(String[] args) {
        Convolution convolution = new Convolution(5);
        convolution.generateConvolutionNumber();
        convolution.vprintf();
    }

}

结果：
  1 16 15 14 13
  2 17 24 23 12
  3 18 25 22 11
  4 19 20 21 10
  5 6  7  8  9

　　这是我的解决方法，主要是将回旋划分为从上到下，从左到右，从下到上，从右到左的四个方向分别处理，要注意后两个方向与正常的数组输出方向相反。这道算法题对学生党来说有点压力，但是掌握了能够写出好多好玩的东西，比如贪吃蛇。上面的算法只是一种可能的实现，欢迎读者贴上自己的代码，交流交流！

　　根据读者回复，可以通过初始化将所有的数组元素赋值为 n * n 的方式，解决当 n 为奇数时，螺旋输出为默认值0的问题，下面贴上代码：

package org.warnier.zhang.exercises;

public class ConvolutionPro {
    private int n;
    private int[][] array;
    private int number = 1;

    public ConvolutionPro(int n) {
        this.n = n;
        array = new int[n][n];
        init();
    }

    private void init() {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                //使用初始化赋值解决n为奇数的情况！
                array[i][j] = n * n;
            }
        }
    }

    //逆时针方向回旋；
    public void generateConvolutionNumber() {
        //处理迭代“内圈”数字输出；
        int a = 0;
        int b = n -1 - a;
        while (b >= a) {
            //与正常的数组输出方向一致螺旋输出；
            for (int i = a; i <= b; i++) {
                for (int j = a; j <= b; j++) {
                    if (i != b && j == a) {
                        array[i][j] = number++;
                    }
                    if (i == b && j != b) {
                        array[i][j] = number++;
                    }
                }
            }
            
            //与正常的数组输出方向相反螺旋输出；
            for (int i = b; i >= a; i--) {
                for (int j = b; j >= a; j--) {
                    if (i != a && j == b) {
                        array[i][j] = number++;
                    }
                    if (i == a && j != a) {
                        array[i][j] = number++;
                    }
                }
            }
            
            a ++;
            b = n -1 - a;
        }
    }

    public void vprintf() {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.printf("%3d", array[i][j]);
            }
            System.out.println();
        }
    }

}

　　当然，我们自然想到也可以顺时针螺旋输出，相应地调整上面两个for（）的执行顺序即可。