Java 实现输出螺旋矩阵

题目 好记性不如烂笔头，记下来

• 用java实现输入一个50以内的数字num，让这个num的平方数字以螺旋矩阵的方式显示在屏幕上。

  
  TIM截图20180829160501.png

• 图解示例：（如下图↓）
  

  20160709135942624.png

• 上 代码

public class SpiralMatrix {

    public static void main(String[] args) {
        int n = 5;
        SpiralMatrix s = new SpiralMatrix();
        int[][] data = s.createMatrix(n);
        int wei = calwei(n * n);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                int temp = calwei(data[i][j]);
                for (int k = 0; k < wei - temp; k++) {
                    System.out.print(" ");
                }
                System.out.print(data[i][j] + " ");
            }
            System.out.println();
        }
    }

    public int[][] createMatrix(int n) {
        // n*n的二维数组，初始元素值都为0
        int[][] matrix = new int[n][n];
        // 分别表示右下左上四个方向
        int right = 1, down = 2, left = 3, up = 4;
        int direction = right;
        // n阶矩阵，共有n×n个数
        int numb = n * n;
        int i = 0, j = 0;
        for (int p = 1; p <= numb; p++) {
            matrix[i][j] = p;
            // 判断方向向右的情况
            if (direction == right) {
                // 如果当前位置的右面位置在右边界内且值还是初始值，则行不变，列号向右移动一位
                if (j + 1 < n && matrix[i][j + 1] == 0) {
                    j++;
                } else {
                    // 如果超出右边边界，或者右面的元素已经被修改过，则向下移动一行，且将方向改为向下
                    i++;
                    direction = down;
                    continue;
                }

            }
            // 判断方向向下的情况
            if (direction == down) {
                // 如果当前位置的下面位置在下边界内且值还是初始值，则列不变，行号向下移动一位
                if (i + 1 < n && matrix[i + 1][j] == 0) {
                    i++;
                } else {
                    // 如果超出下边界，或者下面的元素已经被修改过，则向左移动一行，且将方向改为向左
                    j--;
                    direction = left;
                    continue;
                }
            }
            // 判断方向向左的情况
            if (direction == left) {
                // 如果当前位置的左面位置在左边界内且值还是初始值，则行不变，列号向左移动一位
                if (j - 1 >= 0 && matrix[i][j - 1] == 0) {
                    j--;
                } else {
                    // 如果超出左边界，或者左面的元素已经被修改过，则向上移动一行，且将方向改为向上
                    i--;
                    direction = up;
                    continue;
                }
            }
            // 判断方向向上的情况
            if (direction == up) {
                // 如果当前位置的上面位置在上边界内且值还是初始值，则列不变，行号向左移动一位
                if (i - 1 >= 0 && matrix[i - 1][j] == 0) {
                    i--;
                } else {
                    // 如果超出上边界，或者上面的元素已经被修改过，则向右移动一列，且将方向改为向右
                    j++;
                    direction = right;
                    continue;
                }
            }

        }
        return matrix;

    }

    // 为了将矩阵补齐，看起来好看一些
    public static int calwei(int num) {
        if (num / 10 < 1) {
            return 1;
        }
        if (num / 100 < 1) {
            return 2;
        }
        if (num / 1000 < 1) {
            return 3;
        }
        if (num / 10000 < 1) {
            return 4;
        }
        if (num / 100000 < 1) {
            return 5;
        }
        if (num / 10000000 < 1) {
            return 6;
        }
        if (num / 100000000 < 1) {
            return 7;
        } else {
            return 0;
        }

    }

}

• 另外一种实现方案

public class printcircle {
 
    public static void main(String[] args) {
    int n=3;
    
    int sum=n*n;
    int wei=calwei(sum);
    int A[][]=new int[n][n];
    A[0][0]=1;
    
    //算左上至右下的对角线的值
    for(int i=0;i<n/2;i++){
       A[i+1][i+1]=A[i][i]+4*(n-2*i-1);
    }   
    
    //计算每行上面横向的值
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n-i;j++){
            A[i][j]=A[i][j-1]+1;
        }
    }   
    
    
    //计算每列右边竖向的值
    for(int i=n-1;i>=0;i--){
        for(int j=n-i-1;j<i;j++){
            A[j+1][i]=A[j][i]+1;
        }
    }   
    
    
    //计算每行下面横向的值
    for(int i=n-1;i>n/2;i--){
        for(int j=i;j>n-i-1;j--){
            A[i][j-1]=A[i][j]+1;
        }
    }
    
    //计算每列左边竖向的值
    for(int i=0;i<n/2;i++){
        for(int j=n-1-i;j>i+1;j--){
            A[j-1][i]=A[j][i]+1;
        }
    }
    
    
    //处理输入的值为偶数的情况  
    if(n%2==0){
        A[n/2][n/2-1]=sum;
    }
    
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            int temp=calwei(A[i][j]);
            for(int k=0;k<wei-temp;k++){
                System.out.print(" ");
            }
            System.out.print(A[i][j]+" ");
        }   
        for(int s=0;s<wei-1;s++){
            System.out.println();
        }
        }
    }
    
    //为了将矩阵补齐，看起来好看一些
    public static int calwei(int num){
        int wei=1;
        if(num/10<1) return 1;
        if(num/100<1) return 2;
        if(num/1000<1) return 3;
        if(num/10000<1) return 4;
        if(num/100000<1) return 5;
        if(num/10000000<1) return 6;
        if(num/100000000<1) return 7;
        else return 0;
        
    }
 
}