螺旋矩阵问题

package com.spider.framwork;

import java.util.Scanner;

/**螺旋矩阵的demo（面向像我一样数学不好，脑袋不大灵光的java初学者）
* 思路：1、确定圈数的规律 2、确定方向的规律 3、确定每一圈的起始位置
* 画四个模型图，从少到多，方便我们在其中摸索出数据递增时的规律
* 1 2
* 4 3
*
* 1 2 3
* 8 9 4
* 7 6 5
*
*  1  2  3 4
* 12 13 14 5
* 11 16 15 6
* 10  9 8  7
*
* 1  2  3  4  5
* 16 17 18 19 6
* 15 24 25 20 7
* 14 23 22 21 8
* 13 12 11 10 9
*/
public class MatrixDemo {
private int startNum = 1;
//矩阵的一条边长，写这么长是因为矩阵这个单词不认识，多写几遍，顺便背个单词
private int matrixSideLen;
private int turnsNumber;

//矩阵的本体，一个边长为变量的二维数组
private int[][] matrix;

//通过构造器获得矩阵的大小和边长
public MatrixDemo(int matrixSideLen) {
this.matrixSideLen = matrixSideLen;
matrix = new int[matrixSideLen][matrixSideLen];
/**
* 根据获得圈数的方法
* 思路：通过矩阵的大小递增，我们可以发现，圈数是边长每加到奇数值加一圈,偶数不变，所以可以猜测规律为(matrixSide+1)/2
*/
turnsNumber = (matrixSideLen + 1) / 2;
createMatrix();
for(int i = 0; i < matrixSideLen; i++){
for(int m = 0; m < matrixSideLen; m++){
if(matrix[i][m] < 10){
System.out.print(String.valueOf(matrix[i][m]).concat("  "));
}
else{
System.out.print(String.valueOf(matrix[i][m]).concat(" "));
}
}
System.out.println();
}
}

/**
* 获得当前圈数起始数值
* @param turnIndex
* @return
*/
private int getCornerStartNumber(int turnIndex){
int startIndex = 1;//设置初始值
int sideNumber = matrixSideLen - 1;//因为每条边有一个数字是重叠的，所以-1，周长值的1/4;
//获得当前圈数上层圈数的周长总和
for(int i = 0; i<(turnsNumber - 1); i++){
startIndex += sideNumber * 4;
//因为每一层依次会少两个数字
sideNumber -= 2;
continue;
}
return startIndex;

}

/**
* 获得当前圈每条边数字个数
*/
private int getSideNumberCount(int turnIndex){
return (matrixSideLen - 1) -(turnIndex - 1) * 2;
}

/**
* 生成当前圈
* @param turnIndex
*/
private void createConcurrentTurn(int turnIndex){
int startIndex = getCornerStartNumber(turnIndex);//获得当前圈起始值
int sideNumberCount = getSideNumberCount(turnIndex);//获得每条边数字个数
for(int i = 0; i < 4; i++){
createSide(i, startIndex, sideNumberCount, turnIndex);
continue;
}
}

/**
*
* @param direction 方向
* @param startIndex 起始值
* @param sideNumberCount 边值
* @param turnsIndex 圈定位
*/
private void createSide(int direction, int startIndex, int sideNumberCount, int turnsIndex){
int cell = 0;//数组列坐标
int row = 0;//数组行坐标
switch (direction){
//→方向：行不变，列递增
case 0:
row  = turnsIndex - 1;
cell = turnsIndex - 1;
for(int i = 0; i < sideNumberCount; i++){
matrix[row][cell + i] = startNum;
startNum++;
continue;
}
break;
//↓方向：列不变，行递增
case 1:
row = turnsIndex - 1;
cell = turnsIndex + sideNumberCount - 1;
for(int i = 0; i < sideNumberCount; i++){
matrix[row + i][cell] = startNum;
startNum++;
continue;
}
break;
//←方向：行不变，列递减
case 2:
row = turnsIndex + sideNumberCount - 1;
cell = turnsIndex + sideNumberCount - 1;
for(int i = 0; i < sideNumberCount; i++){
matrix[row][cell - i] = startNum;
startNum++;
continue;
}
break;
//↑方向:行递减，列不变
case 3:
row  = turnsIndex + sideNumberCount - 1;
cell = turnsIndex - 1;
for(int i = 0; i < sideNumberCount; i++) {
matrix[row - i][cell] = startNum;
startNum++;
continue;
}
break;
}
}

private void createMatrix(){
for(int i = 0; i < turnsNumber; i++){
int temp = i + 1;
createConcurrentTurn(temp);
}
if(matrixSideLen % 2 == 1){
matrix[matrixSideLen / 2][matrixSideLen / 2] = matrixSideLen * matrixSideLen;
}
}

public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
MatrixDemo matrixDemo = new MatrixDemo(scanner.nextInt());
}
}