Java 2D数组螺旋/顺时针遍历

这个问题之前已经在stackoverflow上讨论过了，我专门询问关于我的代码的意见或答案，它是否可以在不进行大修的情况下处理不平衡的2d数组。它无法打印一些平衡数组的结尾的原因一定是一些较小的问题在底部更新

基本上，我们有一个由命令行驱动的文本文件提供的2d数组。该文件的每个试验都用换行符分隔，如下所示：行；柱；值（以空格分隔）

例：4；4.123456789101121314141516

输出：1234816141395671110

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package spiralprinting;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 *
 * @author Paul
 */
public class SpiralPrinting {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws FileNotFoundException, IOException {
        // TODO code application logic here
        File file = new File(args[0]);
        BufferedReader in = new BufferedReader(new FileReader(file));
        String line;
        while ((line = in.readLine()) != null) {

            String[] lineArray = line.split(";");
            if (lineArray.length > 0) {//ignore blank line inputs
                //Process line of input Here

                //Max ,minimum, and current indexes in our matrix.
                int maxX = Integer.parseInt(lineArray[0]) - 1;
                int maxY = Integer.parseInt(lineArray[1]) - 1;
                int minX = 0;
                int minY = 0;
                int x = 0;
                int y = 0;

                //Build our matrix
                String[] valueArray = lineArray[2].split("\\s");
                String[][] matrix = new String [Integer.parseInt(lineArray[0])][Integer.parseInt(lineArray[1])];
                int count = 0;

                for (int j = 0; j <= maxY; j++){
                    for (int i = 0; i <= maxX; i++){
                        matrix[i][j] = (valueArray[count]);
                        count++;
                    }
                }

                StringBuilder printString = new StringBuilder();
                //Traverse and print our matrix in a spiral!
                while (maxX > minX && maxY > minY){
                    //Leaving this in and commented so you can see my train of thought.

                    if (x != maxX){
                        while (x < maxX){
                            printString.append(matrix[x][y]).append(" ");
                            x++;
                        }maxX--;
                    }
                    if (y != maxY){
                        while (y < maxY){
                            printString.append(matrix[x][y]).append(" ");
                            y++;
                        }maxY--;
                    }
                    if (x != minX){
                        while (x > minX){
                            printString.append(matrix[x][y]).append(" ");
                            x--;
                        }minX++;
                    }
                    if (y != minY){
                        while (y > minY){
                            printString.append(matrix[x][y]).append(" ");
                            y--;
                        }minY++;
                    }
                    //One border done (4 passes). Next iteration of while-loop begins.
                    x = minX;
                    y = minY;
                }//end of our traversal loop
                //Print it !
                System.out.println(printString.toString().trim());
            }
        }//end of input line analysis
    }
}//end of class

/*
*要更改此模板，请选择工具|模板
*然后在编辑器中打开模板。
*/
包装螺旋印刷；
导入java.io.BufferedReader；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
/**
*
*@作者保罗
*/
公营印刷{
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）抛出FileNotFoundException、IOException{
//此处的TODO代码应用程序逻辑
File File=新文件（args[0]）；
BufferedReader in=新的BufferedReader（新文件读取器（文件））；
弦线；
而（（line=in.readLine（））！=null）{
String[]lineArray=line.split（“；”）；
如果（lineArray.length>0）{//忽略空行输入
//在这里处理输入行
//矩阵中的最大、最小和当前索引。
int maxX=Integer.parseInt（lineArray[0]）-1；
int maxY=Integer.parseInt（lineArray[1]）-1；
int minX=0；
int minY=0；
int x=0；
int y=0；
//建立我们的矩阵
字符串[]valueArray=lineArray[2]。拆分（\\s”）；
字符串[][]矩阵=新字符串[Integer.parseInt（lineArray[0]）][Integer.parseInt（lineArray[1]）；
整数计数=0；
对于（int j=0；j minY）{
//把这个放在这里，发表评论，这样你就可以看到我的思路了。
如果（x！=maxX）{
while（xminX）{
printString.append（矩阵[x][y]）.append（“”）；
x--；
}minX++；
}
如果（y！=minY）{
while（y>minY）{
printString.append（矩阵[x][y]）.append（“”）；
y--；
}minY++；
}
//完成一个边界（4次）。while循环的下一次迭代开始。
x=minX；
y=minY；
}//遍历循环结束
//打印出来！
System.out.println（printString.toString（）.trim（））；
}
}//输入行结束分析
}
}//下课

样本输入和电流输出：

四,；4.123456789101113141414151314151396711110良好

三,；3.1 2 3 4 5 6 7 8 9--->1 2 3 6 9 8 7 4这无法打印5

三,；4.1 2 3 4 5 6 7 8 9 10 11 12--->1 2 3 6 9 12 11 10 7 4..未能打印结尾处的5 8

四,；3.1 2 3 4 5 6 7 8 9 10 11 12--->1 2 3 4 8 12 11 10 9 5..再次打印最后2个失败：6，7“

2、 10；1……20--->1，2，4，6，8……很好

经过一些快速的修改，我的问题似乎是，它没有打印一些集的最后2个。我确信这是一个特殊的情况，我要睡觉了：）

我们仍然非常感谢您的帮助，尤其是如果您认为问题比我目前所认为的更严重的话。我昏昏欲睡的大脑认为我需要2个特殊情况来配合我在while循环中的4个检查

---

谢谢你=]

当你在调试某件事情时，你无法集中精力思考出了什么问题……把它分解成一些易于调试的东西，扔掉你的硬测试用例，尝试一些非常简单的东西，然后转到更难的测试用例，找出哪里出了问题，我就是这样发现的

我注释掉了您输入文件的所有代码，并将您的输入设置为固定字符串：

String[] lineArray = ("3;2;" +
                           "1 2 3 " +
                           "6 5 4 ").split(";"); 
// see how the output should be 123456...very easy to see and debug

当（maxX>minX | | maxY>minY）时，我在

上放置一个断点，查看矩阵数组，发现矩阵的大小是2x3而不是3x2，并且我的数字没有按我认为应该的方式存储。瞧，发现了问题

/*if (maxY >= maxX){*/
    // This for loop is what you want
    for (int j = 0; j <= maxY; j++){
        for (int i = 0; i <= maxX; i++){
            matrix[i][j] = (valueArray[count]);
            count++;
        }
    }
/*}/*delete this junk/ else if (maxX > maxY){
    for (int i = 0; i <= maxX; i++){
        for (int j = 0; j <= maxY; j++){
            matrix[i][j] = (valueArray[count]);
            count++;
        }
    }
}*/

/*如果（maxY>=maxX）{*/
//这个for循环就是你想要的
对于（int j=0；j=3）
返回数组[x][y]；
返回getSpiral（数组，x，y，方向+数学PI/2，转数+1）；
}
字符串值=数组[x][y].toLowerCase（）；
数组[x][y]=“完成”；
系统输出打印项次（值）；
返回值+“”+getSpiral（数组，x+速度[0]，y+速度[1]，方向，0）；
}
公共静态int[]getDirection（双角度）{
返回新的int[]{（int）Math.round（Math.cos（angle）），（int）Math.round（Math.sin（angle））}；
}
顺时针遍历

public static String matrixTraverse(int[][] matrix, int startX, int startY){
    String result = "";
    boolean baseCase = startX + 1 == Math.ceil(matrix[0].length / 2.0)
            || startY + 1 == Math.ceil(matrix.length / 2.0);

    for (int i = startX ; i < matrix[0].length - startX ; i++) {
        result += " " + matrix[startY][i];
    }

    for (int i = startY + 1 ; i < matrix.length - startY - 1 ; i++){
        result += " " + matrix[i][matrix[0].length - 1 - startX];
    }

    for (int i = startX ; (matrix.length - 1 != 2 * startY) && (i < matrix[0].length - startX) ; i++){
        result += " " + matrix[matrix.length - 1 - startY][matrix[0].length - 1 - i];
    }

    for (int i = startY  ; (matrix[0].length - 1 != 2 * startX) && (i < matrix.length - startY - 2) ; i++){
        result += " " + matrix[matrix.length - 2 - i][startX];
    }

    if (!baseCase) {
        result += matrixTraverse(matrix, ++startX, ++startY);
    }

    return result;

}

公共静态字符串矩阵traverse（int[][]矩阵，int startX，int startY）{
字符串结果=”；
布尔baseCase=startX+1==Math.ceil（矩阵[0].length/2.0）
||startY+1==Math.ceil（matrix.length/2.0）；
对于（int i=startX；ipublic static String matrixTraverse(int[][] matrix, int startX, int startY){
    String result = "";
    boolean baseCase = startX + 1 == Math.ceil(matrix[0].length / 2.0)
            || startY + 1 == Math.ceil(matrix.length / 2.0);

    for (int i = startX ; i < matrix[0].length - startX ; i++) {
        result += " " + matrix[startY][i];
    }

    for (int i = startY + 1 ; i < matrix.length - startY - 1 ; i++){
        result += " " + matrix[i][matrix[0].length - 1 - startX];
    }

    for (int i = startX ; (matrix.length - 1 != 2 * startY) && (i < matrix[0].length - startX) ; i++){
        result += " " + matrix[matrix.length - 1 - startY][matrix[0].length - 1 - i];
    }

    for (int i = startY  ; (matrix[0].length - 1 != 2 * startX) && (i < matrix.length - startY - 2) ; i++){
        result += " " + matrix[matrix.length - 2 - i][startX];
    }

    if (!baseCase) {
        result += matrixTraverse(matrix, ++startX, ++startY);
    }

    return result;

}