顺时针打印矩阵 java 实现

88 阅读1分钟

输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字。

本文讲一下我在做这道题时候出现的问题和解决思路,这个代码并不是很好 结果上看4ms 10%用户
但是还是讲一下我遇到的问题 

1.如何打印row一行并且不会在换成col的时候越界

为什么这个问题会产生呢。

平时我们打印数组不就是 fori

for (int i = 0; i < matrix.length; i++) {
   
}

但是在你结束循环之后你的i 值为matrix.length 而java 是0到 matrix.length-1 你在此时读取i会数组越界.

你可能会想我为什么要在matrix.length读下一个数呢.. ( •̀ ω •́ )✧ 嗯 铁子 我们现在是二维数组 水很深好不好

我们在row变col时 会读到matrix.length 那我们的解决方法呢 很简单 1 2 3 4 5 6 一共五个数据 我们只读前四个 让 6在被col的时候读取

假设 
{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
}
这样读 循环一 1 2 循环二 3 6 循环三 9 8 循环四 有点特殊看下面的第二个问题 

如何不读成一个圆

好奇怪的问题是吧

为什么会出现呢

{
RowId 0 {1, 2, 3},
RowId 1 {4, 5, 6},
RowId 2 {7, 8, 9},
}
在读取 col 的时候 先是 3 6 9 后面是 7 4 
什么意思 第一次读三个数据 第二次读两个数据
很好实现对不对 少循环一次呗
你有没有考虑过如果你是用col读取的比如 fori 循环两次对吧 假设进来的时候rowId 2  循环第一次rowId--
把7读进去 rowId = 1 再循环一次 rowId -- 把 4 读进去 rowId 这时候等于0了
不出意外的话你下一个 进入的数据是 1 因为 执行 nums[index] = matrix[rowId++][colId]

那么如何做呢 很简单 只循环一次 并执行nums[index++] = matrix[rowId++][colId]

让他读到同样的4

但是colId没有减少 rowId增加 到时候就会执行成功

贴上执行成功代码 我还用了安全插入 防止数组越界


public boolean nums_In(int[] nums, int index, int value) {
    if (index < nums.length)
        nums[index] = value;
    else return false;
    return true;
}

 public int[] spiralOrder(int[][] matrix) {

        if (matrix.length == 0) return new int[]{};
        int rowId = 0, rowMax = matrix.length,
                colId = 0, colMax = matrix[0].length;
        int cLol = 1;
        int rRol = 1;
        // rowId ++ 是向右
        // colId ++ 是向下
//        while ()
        boolean control = true;
        int[] nums = new int[rowMax * colMax];
        int index = 0;
        while (rowMax >= 1 || colMax >= 1) {
            if (control) {
                while (colId < colMax - 1) {
                    nums_In(nums, index, matrix[rowId][colId++]);
                    index++;
                }
                while (rowId < rowMax - 1) {
                    if (!nums_In(nums, index, matrix[rowId++][colId])) {
                        break;
                    }
                    index++;
                }
                control = false;
            } else {
                while (colId >= cLol) {
                    if (!nums_In(nums, index, matrix[rowId][colId--])) {
                        break;
                    }
                    index++;
                }

                while (rowId > rRol) { //5->3 3->1
                    if (!nums_In(nums, index, matrix[rowId--][colId])) {
                        break;
                    }
                    index++;
                }
                rRol++;
                control = true;
                rowMax -= 1;
                colMax -= 1;
                cLol++;
                if (index < matrix.length * matrix[0].length)
                    nums[index++] = matrix[rowId][colId++];
                System.out.println();

            }
        }


        return nums;
    }

测试数据

        int[][] nums = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9},
        };
        int[][] nums1 = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}};
//        4 -> 2
//        3->1
        int[][] nums2 = {
                {3},
                {2}
        };
        int[][] nums3 = {
                {1, 2, 3, 4, 5},
                {6, 7, 8, 9, 10},
                {11, 12, 13, 14, 15},
                {16, 17, 18, 19, 20},
                {21, 22, 23, 24, 25}
        };
        int[][] nums4 = {
                {2, 3, 4},
                {5, 6, 7},
                {8, 9, 10},
                {11, 12, 13}
        };

最后本人水平有限 文章难免出现错误 敬请指出 希望我们一同成长