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