编程输出以下格式的数据。

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num = scanner.nextInt();
        num=num*2+1;
        System.out.println("请输入你要打印的顺序(true为正序false逆序)：");
        boolean flag=scanner.nextBoolean();
        int[][] array = printArray(num, flag);
        System.out.println("打印结果为：");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }
    }
    private static int[][] printArray(int n,boolean flag){
        int[] numArray = new int[n * n];
        for (int i = 0; i < numArray.length; i++) {
            if (flag){
                numArray[i]=i+1;
            }else {
                numArray[i]=numArray.length-i;
            }
        }
        int index=0;
        // 确定层数
        int num=n%2==0?n/2:n/2+1;
        int[][] arr = new int[n][n];
        //从外层往内层遍历
        for (int i = 0; i < num; i++) {
            // 从右到左
            for (int j = n-i-1; j >=i; j--) {
                arr[i][j]=numArray[index++];
            }
            // 从上到下
            for (int j = i+1; j <n-i ; j++) {
                arr[j][i]=numArray[index++];
            }
            // 从左到右
            for (int j = i+1; j < n-i; j++) {
                arr[n-i-1][j]=numArray[index++];
            }
            // 从下到上
            for (int j = n-i-2; j >i; j--) {
                arr[j][n-i-1]=numArray[index++];
            }
        }
        return arr;
    }

萌新  暴力垃圾解法  不知道自己怎么想的写着写着就编出来了。。

/
 野猪佩奇无算法解题法 /
import java.util.;
 public class BuyBook{
 /
 public class BuyBook{
 /
@ 定义一个全局变量来存数 /
 public static int num=1;
 public static void main(String args[]) {
 Scanner sc=new Scanner(System.in);
 int n=sc.nextInt();
 int x=1;//数组的行
 int y=1;//数组的列
 int count=1;//每次逆时针需要减去的序列，每次递增2
 int a[][]=new int[n+2][];
 for(int i=0;i<n+2;i++) {//先遍历赋值不规则数组
 if(i==0||i==n+1) {
 a[i]=new int[n];
 }
 else {
 a[i]=new int[n+2];
 }
 }
 for(int i=0;i<n;i++) {
 a[0][i]=num;
 num++;

}
for(int i=0;i<n;i++) {
    a[i+1][n+1]=num;
    num++;
}
for(int i=n-1;i>=0;i--) {
    a[n+1][i]=num;
    num++;
}
for(int i=n;i>=1;i--) {
    a[i][0]=num;
    num++;
}for(int i=0;i<n;i++) {
        if(x<=(n+1)/2&&x==y&&a[x][y]==0) {//逆时针遍历数组    找到四个点遍历！！！
            for(int j=1;j<=n+1-count;j++)
            {if(a[x][y]==0) {
            a[x][y]=num;
            num++;}++y;
            }

            y--;//因为y会溢出  所以要减1  下面同理

        }
        if(x+y==n+1&&y>(n+1)/2) {
            for(int j=1;j<=n+1-count;j++) {
                if(a[x][y]==0)
                {a[x][y]=num;

            num++;}++x;
            }--x;

        }
            if(x>(n+1)/2&&x==y) {
                for(int j=1;j<=n+1-count;j++) {
                    if(a[x][y]==0) {
                    a[x][y]=num;
                    num++;}
                    --y;    }++y;

            }
                if(x+y==n+1&&y<=(n+1)/2) {
                    for(int j=1;j<=n+1-count;j++) {
                        if(a[x][y]==0) {
                        a[x][y]=num;
                        num++;}
                        --x;}
                    x+=2;
                    y++;//遍历要回到   逆时针的尾部而非头部   如果是头部则无法继续遍历  出现错误！
                    count+=2;}} 

System.out.println(x+" "+y);
for(int i=0;i<n+2;i++) {
    for(int j=0;j<a[i].length;j++) {
        System.out.print(a[i][j]+" ");
    }
    System.out.println();
}
    }}

import itertools


def spiral(init):
    # 定义生成的行数
    hang = 2 * init + 1
    # 右面开始，逆序生成螺旋数组
    status = itertools.cycle(['left', 'down', 'right', 'up'])  # 用于状态周期性的切换
    movemap = {
        'right': (1, 0),
        'down': (0, 1),
        'left': (-1, 0),
        'up': (0, -1),
    }
    # 初始化二维数组
    position_map = dict.fromkeys([(x, y) for x in range(hang) for y in range(hang)])
    # 初始化当前位置以及当前方向
    positon = (hang-1,0)
    # 从25开始向左
    new_status = next(status)
    # 从最大值开始
    for i in range(hang * hang, 0, -1):
        old_positon = positon
        positon = tuple(map(sum, zip(positon, movemap[new_status])))
        # 如果超过范围或者碰到已经有值的位置则切换方向
        if (positon not in position_map) or (position_map[positon]):
            new_status = next(status)
            positon = tuple(map(sum, zip(old_positon, movemap[new_status])))
        # 相当于自加
        position_map[old_positon] = i

    print("When init={}".format(init))
    for i in range(hang):
        for j in range(hang):
            print((position_map[(j, i)]), end='\t')
        print('\n')


if __name__ == "__main__":

    spiral(3)

//螺旋数组

#coding=utf-8
#思路：逆时针绕圈螺旋，需要知道起始位置，上下左右走的步数以及最后终止的结束位置。
def getarray(n):
    res = [[0]*(n*2+1) for i in range(n*2+1)] # 初始化螺旋数组
    # return res
    if n == 0:
        return [[1]]
    res[n][n] = 1  # 中心点
    startX = n  # 起始点坐标x
    startY = n+1  # 起始点坐标y
    steps = 2  # 上下左右需要走的步数
    val = 2  # 赋值
    while startX != 0:  # 范围是1-n
        x = startX
        y = startY
        res[x][y] = val  # 起始点
        # 向下走
        for i in range(1,steps): 
            val += 1
            x += 1
            res[x][y] = val  # 起始点
        # 向左走
        for i in range(steps):
            val += 1
            y -= 1
            res[x][y] = val 
        # 向上走
        for i in range(steps):
            val += 1
            x -= 1
            res[x][y] = val
        # 向右走
        for i in range(steps):
            val += 1
            y += 1
            res[x][y] = val 
        val += 1
        startX -= 1
        startY += 1
        steps = steps+2
    return res
 
if __name__ == "__main__":
    n = int(raw_input())
    res = getarray(n)
    for i in range(len(res)):
        for j in res[i]:
            print str(j)+' ',
        print '\n'

#include
#define N 100//使数组尽量大一点
int main()
{
    int a[N][N];
    int i,j,n,x1,x2;
    int key;
    scanf("%d",&key);
    n=2*key+1;
    x1=n-1;
    x2=0;
    j=n*n;
    do
    {
        for(i=x1;i>=x2;i--,j--)
        {
            a[x1][i]=j;
        }
        for(i=x1-1;i>=x2;i--,j--)
        {
            a[i][x2]=j;
        }
        for(i=x2+1;i<=x1;i++,j--)
        {
            a[x2][i]=j;
        }
        for(i=x2+1;i<=x1-1;i++,j--)
        {
            a[i][x1]=j;
        }
        x1--;
        x2++;
    }while(x1>=x2);
    for(i=n-1;i>=0;i--)
    {
        for(j=0;j<n;j++)
            printf("%2d ",a[j][i]);
        printf("\n");
    }
}

/*
*编程输出以下格式的数据。
*When i=0
*1
*When i=1
*7   8   9
*6   1   2
*5   4   3
*When i=2
*21  22  23  24  25
*20  7   8   9   10
*19  6   1   2   11
*18  5   4   3   12
*17  16  15  14  13
* */
public class PrintFormatLuoXuan {
    public static void main(String[] args){
        printLuoXuan(0);
        printLuoXuan(1);
        printLuoXuan(2);
        printLuoXuan(3);
    }
    static int res[][] ;
    /*
    * *************************************************************
    * 实现思路：
    * *************************************************************
    * 1、这是一个(2*i+1)*(2*i+1)的数列；
    * 2、每个数值的计算规则是从最外层右上角开始递减；
    * -------------------------------------------------------------
    * 分析处理办法：
    * -------------------------------------------------------------
    * 1、理解这个数列为一个回字形状的结构，口字逐层嵌套；
    * 总的口字数 = ((2*+1)+1)/2
    * 2、一个口字的四条边的索引和四个顶角的初始值和运算值如下：
    * ------------------------------------------------------------
    * int con = 2*i+1;//first 最外层口字的边长
    * int rows = (con+1)/2;//总的口字数
    * int conu = con -2*r;//每个口字的边长
    * int cons = con -2*(r+1);//上一个口字的边长
    * ------------------------------------------------------------------------------------------------
    *           |        index                   |    initial_value    |     runtime_value
    * ------------------------------------------------------------------------------------------------
    * ------------------------------------------------------------------------------------------------
    * 右上角：upNum：|   [r][r+(conu-1)-c]            |（2*i+1)*(2*i+1)     | riNum(上一个口字的)
    * 左上角：leNum：|   [r+c][r]                     | upNum - (con -1)    | upNum - (cons -1)
    * 左下角：doNum：|   [r+(conu-1)][r+c]            | leNum - (con -1)    | leNum - (cons -1)
    * 右下角：riNum：|   [r+(conu-1)-c][r+(conu-1)]   | doNum - (con -1)    | doNum - (cons -1)
    * ------------------------------------------------------------------------------------------------
    * 3、每个口字的边只循环递减conu - 1次；
    * 4、由于con总是奇数，所以对索引[rows-1][rows-1]的值直接赋值为1；
    * 5、使用for each 和printf()方法遍历结果数组，打印输出；
    * */
    public static void printLuoXuan(int i){
        int con = 2*i+1;//first 最外层口字的边长
        int rows = (con+1)/2;//总的口字数
        res = new int[con][con];
        int upNum = con*con;
        int leNum = upNum - (con -1);
        int doNum = leNum - (con -1);
        int riNum = doNum - (con -1);
        for (int r=0;r<rows;r++){
            int conu = con -2*r;//每个口字的边长
            int cons = con -2*(r+1);//上一个口字的边长
            for (int c=0;c<conu-1;c++){
                //print upRow
                res[r][r+(conu-1)-c] = upNum--;
                //print leftColumn
                res[r+c][r] = leNum--;
                //print downRow
                res[r+(conu-1)][r+c] = doNum--;
                //print rightColumn
                res[r+(conu-1)-c][r+(conu-1)] = riNum--;
            }
            upNum = riNum;
            leNum = upNum - (cons -1);
            doNum = leNum - (cons -1);
            riNum = doNum - (cons -1);
        }
        //for res[rows-1][rows-1] 赋值
        res[rows-1][rows-1] = 1;
        //print out result
        for (int[] es:res){
            for (int e:es){
                System.out.printf("%4d",e);
            }
            System.out.println();
        }
    }
}

	

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Software: PyCharm

global num
def right(i):
    global arr
    for k in range(1,2 * i + 1):
        arr[num+k-i][num+i] = k + arr[num-i+1][num+i-1]
def down(i):
    for k in range(1,2 * i + 1):
        arr[num+i][num-k+i] = k + arr[num+i][num+i]
def left(i):
    for k in range(1,2 * i + 1):
        arr[num-k+i][num-i] = k + arr[num+i][num-i]
def up(i):
    for k in range(1,2 * i + 1):
        arr[num-i][num-i+k] = k + arr[num-i][num-i]
def screw_num_display():
    n = num * 2 + 1
    global arr
    arr = [[0 for i in range(n)] for j in range(n)]
    arr[num][num] = 1
    for i in range(1,num+1):
        right(i)
        down(i)
        left(i)
        up(i)
    for i in range(n):
        print(arr[i])
num = int(raw_input('请输入一个整数'))
screw_num_display()