螺旋矩阵

题目：

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

 

螺旋矩阵 三要素 定义： 拐点（四个角），方向还有指向。

东哥的代码

将方向跟指向合在一起

List<Integer> spiralOrder(int[][] matrix) {
    int m = matrix.length, n = matrix[0].length;
    int upper_bound = 0, lower_bound = m - 1;
    int left_bound = 0, right_bound = n - 1;
    List<Integer> res = new LinkedList<>();
    // res.size() == m * n 则遍历完整个数组
    while (res.size() < m * n) {
        if (upper_bound <= lower_bound) {
            // 在顶部从左向右遍历
            for (int j = left_bound; j <= right_bound; j++) {
                res.add(matrix[upper_bound][j]);
            }
            // 上边界下移
            upper_bound++;
        }
        
        if (left_bound <= right_bound) {
            // 在右侧从上向下遍历
            for (int i = upper_bound; i <= lower_bound; i++) {
                res.add(matrix[i][right_bound]);
            }
            // 右边界左移
            right_bound--;
        }
        
        if (upper_bound <= lower_bound) {
            // 在底部从右向左遍历
            for (int j = right_bound; j >= left_bound; j--) {
                res.add(matrix[lower_bound][j]);
            }
            // 下边界上移
            lower_bound--;
        }
        
        if (left_bound <= right_bound) {
            // 在左侧从下向上遍历
            for (int i = lower_bound; i >= upper_bound; i--) {
                res.add(matrix[i][left_bound]);
            }
            // 左边界右移
            left_bound++;
        }
    }
    return res;
}

我的代码：

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if matrix == []:return []
        n = matrix.__len__()
        m = matrix[0].__len__()
        total_len = m * n
        x ,y = 0,0
        res = []
        flag = 1 # x 变 ，y不变
        forward = 1 # 正的方向为1 
        forward_step = 0 # 每走两个正方向 就变成 负方向 ，step重置为0
        
       
        left = 0
        right = m
        up =  0
        down = n
        while total_len > res.__len__():
            if flag and forward:
                for i in range(left,right):
                    res.append(matrix[y][i])
                x = right -1
                up += 1
                flag = 0
                
            elif not flag and forward:
                
                for j in range(up,down):
                    res.append(matrix[j][x])
                right -= 1
                flag = 1
                y = down -1
                forward = 0
            elif not forward and flag:
                for j in range(right-1,left-1,-1):
                    res.append(matrix[y][j])
                down -= 1
                flag = 0
                x = left 
            elif not flag and not forward:
                for j in range(down-1,up-1,-1):
                    res.append(matrix[j][x])
                left += 1                
                flag = 1
                y = up  
                forward = 1
        return res