LeetCode--054--区螺旋矩阵(java)

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]

示例 2:

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

思路：把每次打印看成是打印当前矩阵的外圈，当前矩阵打印完成后，找到其子矩阵，继续打印子矩阵的外圈。
比如例子1的矩阵  1  2  3
               4     6
               7  8  9    
如何确定一个矩阵，只需要确定其左上角的点和右下角的点，我们把左上角的点即为(tR,tC) 把右下角的点记为(dR,dC)
(0,0) (2,2)即为上面矩阵的两个点，打印一圈后，左上角的点往右下移动一个位置，右下角的点往左上移动一个位置，停止条件为，左上角的点跑到右下角点的右边或者下边。

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> list = new ArrayList<>();
        if(matrix.length == 0 || matrix == null)return list;
        int tR = 0;
        int tC = 0;
        int dR = matrix.length - 1;
        int dC = matrix[0].length - 1;
        while (tR <= dR && tC <= dC){
            printEdge(matrix,tR++,tC++,dR--,dC--,list);
        }
        return list;
    }
    public static void printEdge(int[][] m,int tR,int tC,int dR,int dC,List<Integer> list){
        if(tR == dR){
            for(int i = tC;i <= dC;i++){
                list.add(m[tR][i]);
            }
        }else if (tC == dC){
            for(int i = tR;i <= dR;i++){
                list.add(m[i][tC]);
            }
        }else{
            int curC = tC;
            int curR = tR;
            while(curC != dC){
                list.add(m[tR][curC]);
                curC++;
            }
            while (curR != dR){
                list.add(m[curR][dC]);
                curR++;
            }
            while(curC != tC){
                list.add(m[dR][curC]);
                curC--;
            }
            while(curR != tR){
                list.add(m[curR][tC]);
                curR--;
            }
        }
    }
}

python:

class Solution:
    def draw(self,tR,tC,dR,dC,matrix,lists):
        flag = False
        i = tC
        j = tR
        while(i <= dC): 　　　　　　　　　　#向右走
            lists.append(matrix[tR][i])
            print(i)
            i+=1
        i-=1
        j+=1
        while(j <= dR):                  #向下走
            
            lists.append(matrix[j][dC])
            j+=1
        j-=1
        i-=1
        if j == dR and dR != tR:         #向左走
            while(i >=tC):
                lists.append(matrix[dR][i])
                i-=1
                flag = True
            i += 1
        j -= 1
        if i == tC and flag:     #没往左走则不往上走   
            while(j > tR):
                lists.append(matrix[j][tC])
                j-=1
            j += 1
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if len(matrix) == 0:
            return []
        if len(matrix[0]) == 1:
            return [matrix[i][0] for i in range(len(matrix))]  #一列的情况
        if len(matrix) == 1:
            return [matrix[0][i] for i in range(len(matrix[0]))]  #一行的情况
        tR = tC = 0
        dR = len(matrix) - 1
        dC = len(matrix[0]) - 1
        lists = []
        while dR >= tR and dC >= tC:
            self.draw(tR,tC,dR,dC,matrix,lists)
            tR += 1
            tC += 1
            dR -= 1
            dC -= 1
        return lists

 参考:程序员代码面试指南

2019-05-13 15:47:27

2019-08-27 20:08:59