【剑指offer-19】20190809/01 顺时针打印矩阵

【剑指offer-19】顺时针打印矩阵

• 考点：数组
• 时间限制：1秒
• 空间限制：32768K
• 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

---

思路：

我的想法就是从第一行开始先往右走，然后在右边再往下走，然后再往左走，然后再往上走。就是按照题目的意思进行输出。
但是要注意几个问题：

1. 小心重复添加，比如说我们走到最右上角了，准备往下走了，要注意右上角不能重复再加一次。同理右下角，左下角，左上角都要小心不能重复添加。
2. 考虑到只有单一列和单一行的情况。
   在单单一行和单单一列我们执行钱前面两个循环都是没有问题的。
   • 比如说我现在[1, 2, 3, 4, 5]，可以顺利执行前面两个循环。但是到后面两个循环的时候，他要往回走了，这个时候我们是不希望在同一行往回走的，这样就会有重复的情况。因此从右向左边的循环，需要控制不是在同一行，也就是 iStart != iEnd
   • 同理一列的情况，我不希望往上走的时候，是走过同一列的数据，所以第四个循环要控制jStart != jEnd

代码：

下面这个是我的代码。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> array = new ArrayList<Integer>();
        int iStart = 0, jStart = 0;
        int iEnd = matrix.length - 1, jEnd = matrix[0].length - 1;
        int count = iEnd * jEnd;
        while (iStart <= iEnd && jStart <= jEnd) {
            for (int j = jStart; j <= jEnd; j++) {
                array.add(matrix[iStart][j]);
            }
            for (int i = iStart + 1; i <= iEnd; i++) {
                array.add(matrix[i][jEnd]);
            }
            // 控制！
            if (iStart != iEnd) {
                for (int j = jEnd - 1; j >= jStart; j--) {
                    array.add(matrix[iEnd][j]);
                }
            }
            // 控制！
            if (jStart != jEnd) {
                for (int i = iEnd - 1; i > iStart; i--) {
                    array.add(matrix[i][jStart]);
                }
            }
            
            iStart++;
            iEnd--;
            jStart++;
            jEnd--;
        }
        return array;
    }
}

我的问题：

1. 没有考虑同一行同一列的情况。
2. 设置end的时候，可以直接设置成最后一个下标，不要用长度-1，很容易混淆。
3. 我改成最后统一进行范围的缩小的时候是比较清晰的，每走一个循环进行一次范围的变换很有可能会造成错误。
4. 循环执行的条件：允许在同一行或者同一列，所以是iStart <= iEnd && jStart <= jEnd

---

其他思路1：

在这里提供一个别的思路，我觉得挺厉害的。
不过如果魔方规模变大，每次打印一行都要旋转一次耗费一次平方阶时间。

可以模拟魔方逆时针旋转的方法，一直做取出第一行的操作
例如
1 2 3
4 5 6
7 8 9
输出并删除第一行后，再进行一次逆时针旋转，就变成：
6 9
5 8
4 7
继续重复上述操作即可。

        /*
         * 采用旋转魔方的方式 一次取一行，然后旋转
         */
        public ArrayList<Integer> printMatrix_2(int[][] matrix) {
            ArrayList<Integer> al = new ArrayList<>();
            int row = matrix.length;
            while (row != 0) {
                for (int i = 0; i < matrix[0].length; i++) {
                    al.add(matrix[0][i]);
                }
                if (row == 1)
                    break;
                matrix = turn(matrix);
                row = matrix.length;
            }
            return al;
        }
 
        private int[][] turn(int[][] matrix) {
            // TODO 自动生成的方法存根
            int col = matrix[0].length;
            int row = matrix.length;
            int[][] newMatrix = new int[col][row - 1];
            for (int j = col - 1; j >= 0; j--) {
                for (int i = 1; i < row; i++) {
                    newMatrix[col - 1 - j][i - 1] = matrix[i][j];
                }
            }
            return newMatrix;
        }
 
 
 
public ArrayList<Integer> printMatrix_1(int[][] matrix) {
            ArrayList<Integer> al = new ArrayList<>();
            int row = matrix.length;
            if (row == 0)
                return al;
            int col = matrix[0].length;
            // 短的边/2，向上取整
            int circle = ((row > col ? col : row) + 1) / 2;
            for (int i = 0; i < circle; i++) {
 
                // 从左向右打印，j=i; j<col-i,
                // 这一行的前i个已经在第i圈从下往上被打印，故j=i
                // 倒数i个都已经在第i圈从上往下被打印，故j=col-i-1<col-i
                for (int j = i; j < col - i; j++)
                    al.add(matrix[i][j]);
 
                // 从上往下打印，j=i+1;j<row-i,
                // 这一列的前i+1个已经在从左向右打印时被打印,故j=i+1
                // 倒数i个已经在第i圈从右往左被打印,故j=row-i-1<row-i
                for (int j = i + 1; j < row - i; j++)
                    al.add(matrix[j][col - i - 1]);
 
                // 从右往左打印，j=col-i-2;j>=i&&row-i-1!=i;，
                // 这一行倒数i个已经在第i圈从上往下被打印
                // 这一行倒数第i+1个已经在从上往下时被打印，故j=col-1-(i+1)=col-i-2
                // 这一行的前i个已经在从下往上时被打印，故j=i>=i
                // 当第i圈为0时即从未由上往下打印时，col有多列时，会造成重复打印，故判断row-i-1!=i以避免
                for (int j = col - i - 2; j >= i && row - i - 1 != i; j--)
                    al.add(matrix[row - i - 1][j]);
 
                // 从下往上打印，j=row-i-2;j>i&&col-i-1!=i，
                // 这一列倒数i个已经在第i圈从右往作被打印
                // 这一列倒数第i+1个已经在从右往左时被打印，故j=row-1-(i+1)=row-i-2
                // 这一列的前i个已经在第i圈从左往右时被打印，
                // 这一列的第i+1个已经在本圈从左往右被打印，故j=i+1>i
                // 当第i圈为0时即从未由右向左打印时，row有多行时，会造成重复打印，故判断col-i-1!=i以避免
                for (int j = row - i - 2; j > i && col - i - 1 != i; j--)
                    al.add(matrix[j][i]);
            }
            return al;
        }

---