54. Spiral Matrix

Given an m x n matrix, return all elements of the matrix in spiral order.

 

Example 1:


Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [1,2,3,6,9,8,7,4,5]
Example 2:


Input: matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]
 

Constraints:

m == matrix.length
n == matrix[i].length
1 <= m, n <= 10
-100 <= matrix[i][j] <= 100

题目翻译：
给定一个 m x n 的矩阵，以螺旋顺序返回矩阵的所有元素。

示例 1:

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2:

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

约束条件：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 10
-100 <= matrix[i][j] <= 100

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>(); // 创建一个 ArrayList 用于存储螺旋顺序的元素

        if (matrix == null || matrix.length == 0) { // 如果输入的矩阵为空或长度为0，则直接返回空的 ArrayList
            return result;
        }

        int rowBegin = 0; // 行的起始索引
        int rowEnd = matrix.length - 1; // 行的结束索引
        int colBegin = 0; // 列的起始索引
        int colEnd = matrix[0].length - 1; // 列的结束索引

        while (rowBegin <= rowEnd && colBegin <= colEnd) { // 当行和列的起始索引均小于等于结束索引时，继续遍历

            for (int j = colBegin; j <= colEnd; j++) { // 遍历上方的行，从左到右
                result.add(matrix[rowBegin][j]);
            }
            rowBegin++; // 更新行的起始索引，往下移动一行

            for (int i = rowBegin; i <= rowEnd; i++) { // 遍历右侧的列，从上到下
                result.add(matrix[i][colEnd]);
            }
            colEnd--; // 更新列的结束索引，往左移动一列

            if (rowBegin <= rowEnd) { // 如果行的起始索引仍然小于等于结束索引
                for (int j = colEnd; j >= colBegin; j--) { // 遍历下方的行，从右到左
                    result.add(matrix[rowEnd][j]);
                }
            }
            rowEnd--; // 更新行的结束索引，往上移动一行

            if (colBegin <= colEnd) { // 如果列的起始索引仍然小于等于结束索引
                for (int i = rowEnd; i >= rowBegin; i--) { // 遍历左侧的列，从下到上
                    result.add(matrix[i][colBegin]);
                }
            }
            colBegin++; // 更新列的起始索引，往右移动一列
        }

        return result; // 返回存储螺旋顺序元素的 ArrayList
    }
}

best answer
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int row = matrix.length; // 矩阵的行数
        int col = matrix[0].length; // 矩阵的列数
        int top = 0; // 上边界
        int right = col - 1; // 右边界
        int bottom = row - 1; // 下边界
        int left = 0; // 左边界
        List<Integer> result = new ArrayList<>(); // 存储螺旋顺序元素的列表

        while (result.size() < row * col) { // 当列表中的元素数量小于矩阵中的元素总数时继续循环
            for (int j = left; j <= right; j++) { // 从左到右遍历上边界
                result.add(matrix[top][j]); // 将元素添加到结果列表中
            }
            for (int j = top + 1; j <= bottom; j++) { // 从上到下遍历右边界
                result.add(matrix[j][right]); // 将元素添加到结果列表中
            }
            if (top != bottom) { // 如果上边界与下边界不重合
                for (int j = right - 1; j >= left; j--) { // 从右到左遍历下边界
                    result.add(matrix[bottom][j]); // 将元素添加到结果列表中
                }
            }
            if (left != right) { // 如果左边界与右边界不重合
                for (int j = bottom - 1; j > top; j--) { // 从下到上遍历左边界
                    result.add(matrix[j][left]); // 将元素添加到结果列表中
                }
            }
            top++; // 上边界向下移动
            left++; // 左边界向右移动
            right--; // 右边界向左移动
            bottom--; // 下边界向上移动
        }
        return result; // 返回结果列表
    }
}

对于这两个代码，它们的时间复杂度都是 O(m*n)，因为都需要遍历整个矩阵。但是，在实际运行时间上，它们可能会有一定的差异。这主要是因为代码实现的细节不同，以及执行的循环次数有所差别。

在第一个代码示例中，每个方向（上、右、下、左）的遍历都有单独的循环，而且还需要在每次循环结束后更新边界值。这可能导致执行的循环次数相对较多，从而影响实际运行时间。

而在第二个代码示例中，它的实现更加紧凑，将每个方向的遍历合并到一个大循环中。同时，它还在遍历下边界和左边界时添加了条件判断，以避免在边界重合时的重复遍历。这样的实现可能在实际运行中更加高效。

所以，在实际运行时间上，第二个代码可能会比第一个代码更快一些。但从理论上讲，它们的时间复杂度都是 O(m*n)。