首页 > 试题广场 > 顺时针打印矩阵
[编程题]顺时针打印矩阵
输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下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.

75个回答

添加回答
推荐
/*解题思路:顺时针打印就是按圈数循环打印,一圈包含两行或者两列,在打印的时候会出现某一圈中只包含一行,要判断从左向右打印和从右向左打印的时候是否会出现重复打印,同样只包含一列时,要判断从上向下打印和从下向上打印的时候是否会出现重复打印的情况*/
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int>res;
        res.clear();
        int row=matrix.size();//行数
        int collor=matrix[0].size();//列数
        //计算打印的圈数
        int circle=((row<collor?row:collor)-1)/2+1;//圈数
        for(int i=0;i<circle;i++){
            //从左向右打印
            for(int j=i;j<collor-i;j++)
                res.push_back(matrix[i][j]);          
            //从上往下的每一列数据 
            for(int k=i+1;k<row-i;k++)
                res.push_back(matrix[k][collor-1-i]);
            //判断是否会重复打印(从右向左的每行数据) 
            for(int m=collor-i-2;(m>=i)&&(row-i-1!=i);m--) 
                res.push_back(matrix[row-i-1][m]); 
            //判断是否会重复打印(从下往上的每一列数据)
            for(int n=row-i-2;(n>i)&&(collor-i-1!=i);n--) 
                res.push_back(matrix[n][i]);}
        return res;
    }
};


编辑于 2015-09-07 13:31:21 回复(42)

class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result=[]
        while matrix:
            result+=matrix[0]
            matrix=list(zip(*matrix[1:]))[::-1]
        return result

发表于 2019-04-18 14:44:50 回复(0)
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
      
        m=len(matrix)
        n=len(matrix[0])
        left=0
        right=n-1
        up=0
        down=m-1
        direct=0
        res=[]
        if m==0:
            return []
        while True:
            if direct==0:
                for i in range(left,right+1):
                    res.append(matrix[left][i])
                up+=1
            if direct==1:
                for i in range(up,down+1):
                    res.append(matrix[i][right])
                right-=1
            if direct==2:
                for i in range(right,left-1,-1):
                    res.append(matrix[down][i])
                down-=1
            if direct==3:
                for i in range(down,up-1,-1):
                    res.append(matrix[i][left])
                left+=1
            direct=(direct+1)%4
            if left>right or up>down:
                return res
              
发表于 2019-04-12 14:49:10 回复(0)
class Solution:
# matrix类型为二维列表,需要返回列表class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code 
        if not matrix:
            return []
        res = []
        while matrix:
            res += matrix.pop(0)
            matrix = zip(*matrix)[::-1]
        return res

编辑于 2019-04-06 20:34:59 回复(0)
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        if matrix:
            return list(matrix.pop(0)) + self.printMatrix(zip(*matrix)[::-1])
        else:
            return []

发表于 2019-04-06 00:37:11 回复(0)
python 剑指offer解法
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        if matrix==[[]]:
            return
        res=[]
        start=0
        rows=len(matrix)
        columns=len(matrix[0])
        while(rows>start*2 and columns>start*2):
            res += self.PrintMatrixInCircle(matrix,rows,columns,start)
            start+=1
        return res

    def PrintMatrixInCircle(self,matrix,rows,columns,start):
        endX=columns-start-1
        endY=rows-start-1
        res=[]
        #从左到右打印一行
        for i in range(start,endX+1):
            res.append(matrix[start][i])
        #从上到下打印一列
        if start<endY:
            for i in range(start+1,endY+1):
                res.append(matrix[i][endX])
        #从右到左打印一行
        if start<endX and start<endY:
            for i in range(endX-1,start-1,-1):
                res.append(matrix[endY][i])
        #从下到上打印一列
        if start<endX and start<endY-1:
            for i in range(endY-1,start,-1):
                res.append(matrix[i][start])
        return res

发表于 2019-04-05 22:01:08 回复(0)
先取矩阵的第一行,接着将剩下作为新矩阵进行一个逆时针90度的翻转,接着获取第一行,直到矩阵为空。 

发表于 2019-04-05 16:10:13 回复(0)
# 记录下标位置, 走过的位置用'#'标记, 重点在于行走方向的优先级
class Solution:
    def printMatrix(self, matrix):
        if not matrix:
            return
        direction = [[0,1],[1,0],[0,-1],[-1,0]]
        row = len(matrix)
        col = len(matrix[0])
        start = [0, -1]
        res = []
        index = 0
        for i in range(row*col):
            for j in range(index, index+4):
                item = direction[j%4]
                now = [start[0] + item[0], start[1] + item[1]]
                if 0 <= now[0] < row and 0 <= now[1] < col:
                    if matrix[now[0]][now[1]] != '#':
                        res.append(matrix[now[0]][now[1]])
                        matrix[now[0]][now[1]] = '#'
                        start = now
                        index = j%4
                        break
        return res 

发表于 2019-04-02 22:22:24 回复(0)

思路:将矩形不断取上层,然后左转,重复直到矩形为空
```python

# -*- coding:utf-8 -*-
class Solution:
# matrix类型为二维列表,需要返回列表
def printMatrix(self, matrix):
    # write code here
    ret=[]
    while len(matrix)>0:
        ret+=matrix.pop(0)
        matrix=list(zip(*matrix))[::-1]
    return ret
编辑于 2019-03-26 09:51:19 回复(0)
写的超级繁琐。。比不了各位大佬。。

class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        list = []
        while len(matrix) is not 0:
            col = len(matrix[0])
            matrix[0].reverse()
            for i in range(col):
                list.append(matrix[0].pop())
            del matrix[0]
            if len(matrix) == 0:
                return list
            while [] in matrix:
                matrix.remove([])
            row = len(matrix)
            for j in range(row):
                list.append(matri***op(-1))
            while [] in matrix:
                matrix.remove([])
            if len(matrix) == 0:
                return list
            col = len(matrix[0])
            for k in range(col):
                list.append(matrix[row-1].pop(-1))
            del matrix[row-1]
            if len(matrix) == 0:
                return list
            while [] in matrix:
                matrix.remove([])
            row = len(matrix)
            for u in range(row):
                list.append(matrix[row-1].pop(0))
                row -= 1
        return list
发表于 2019-03-24 21:45:35 回复(0)
# -*- coding:utf-8 -*-
#多次逆时针翻转
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        ans = []
        while matrix:
            ans.extend(matrix[0])
            matrix.pop(0)
            if matrix:
                matrix = self.turn(matrix)
        return ans 
    def turn(self, matrix):
        row = len(matrix)
        col = len(matrix[0])
        col_new = row
        row_new = col
        new_matrix = []
        for i in range(row_new):
            new_matrix.append([])
            for j in range(col_new):
                new_matrix[i].append(matrix[j][col-1-i])
        return new_matrix

发表于 2019-03-24 19:28:31 回复(0)

利用python2中的zip函数对矩阵转置,再用list[::-1]作行对调。实现矩阵的逆时针旋转,接着递归打印第一行。

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, M):
        # write code here
        if not M or not M[0]:
            return []
        return self.Recur(M)
    def Recur(self, M):
        if not M:
            return []
        return list(M[0]) + self.Recur( zip(*M[1:])[::-1] )
发表于 2019-03-21 13:35:41 回复(0)
看了python 头位的代码,感觉不太严谨,这种是常规思路,新手勿喷。
class Solution:
    def printMatrix(self, matrix):
        # write code here
        arra = []
        row = len(matrix)
        col = len(matrix[0])
        end = min(row, col)
        row1, col1 = row, col
        for i in range((end + 1) / 2):
            for j in range(i, col - i):
                arra.append(matrix[i][j])
            row1 -= 1
            if row1 and col1:
                for k in range(i + 1, row - i):
                    arra.append(matrix[k][col - 1 - i])
            col1 -= 1
            if row1 and col1:
                for m in range(col - i - 2, i - 1, -1):
                    arra.append(matrix[row - 1 - i][m])
            row1 -= 1
            if row1 and col1:
                for n in range(row - i - 2, i, -1):
                    arra.append(matrix[n][i])
            col1 -= 1
        return arra

发表于 2019-03-20 12:07:04 回复(0)
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result = []
        while matrix:
            for i in range (len(matrix[0])):
                result.append(matrix[0][i])
            if len(matrix) == 1 and len(matrix[0]) == 1: break
            if len(matrix) <= 1: break
            matrix = self.turn(matrix[1: ])
        return result
    def turn(self, matrix):
        lrow = len(matrix)
        lcol = len(matrix[0])
        newmat = []
        for i in range (lcol-1, -1, -1):
            row = []
            for j in range (lrow):
                row.append(matrix[j][i])
            newmat.append(row)
        return newmat
发表于 2019-03-20 10:22:41 回复(0)
#综合了各位的
class Solution:
    def printMatrix(self, matrix):
        ans=[]
        while matrix:
            ans+=matrix.pop(0)
            matrix=zip (*matrix)[::-1]
        return ans
发表于 2019-03-15 01:19:40 回复(0)
Print Matrix  Step by Step
```
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        steprow = 1
        stepcol = 0

        if not matrix: return None
        bm = len(matrix) - 1
        if not bm: return matrix[0]
        um = 0
        rn = len(matrix[0]) - 1
        
        ln = 0
        i = 0
        j = 0
        result = []
        while rn >= ln and um <= bm:

            if ln<=j<=rn and um <=i<=bm:
                result.append(matrix[i][j])
            else:
                break
            if i == um and j == ln and (i != 0 or j != 0):
                steprow = 1
                stepcol = 0
                bm -= 1
            elif i == um and j == rn:
                steprow = 0
                stepcol = 1
                if i!=0:
                    ln += 1
            elif i == bm and j == rn:
                steprow = -1
                stepcol = 0
                um += 1
            elif i == bm and j == ln:
                steprow = 0
                stepcol = -1
                rn -= 1
            i = stepcol + i
            j = steprow + j

        return result
```

发表于 2019-03-14 22:32:35 回复(0)
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        start = 0
        row_m = len(matrix)
        col_m = len(matrix[0])
        res = []
        while col_m>start*2 and row_m>start*2:
            one_cricle = self.printcircle(matrix,start,row_m,col_m)
            res = res+one_cricle
            start += 1
            
        return res
    def printcircle(self,matrix,start,row,col):
        one_cricle = []
        x_end = col-1
        y_end = row-1
        for i in range(start,col-start):  # 正序打印行
            one_cricle.append(matrix[start][i])
        for i in range(start+1,row-start):  # 1,2 正序列
            one_cricle.append(matrix[i][col-start-1])
        if start < y_end-start:
            for i in range(start,col-start-1)[::-1]:  # 逆序行
                one_cricle.append(matrix[row-start-1][i])
        if start < x_end-start:  # 逆序列
            for i in range(start+1, row-start-1)[::-1]:
                one_cricle.append(matrix[i][start])
        return one_cricle
        
发表于 2019-03-12 16:29:58 回复(0)
# 找了个逆时针旋转矩阵的方法,结合上边的经验,自己想了下代码,是真滴秀
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result = []
        while matrix:
            result = result + matrix[0]
            matrix = matrix[1:]
            matrix = list(map(list,zip(*matrix)))[::-1]
        return result
发表于 2019-03-12 11:25:05 回复(0)
# -*- coding:utf-8 -*-
class Solution:
    def printMatrix(self, arr):
        #获得尺寸
        x=len(arr)#行
        if x==0:return arr#一行都没有
        y=len(arr[0])#列
        #特殊情况:
        if x==1: return arr[0]#只有一行
        if y==1 or y==0: return [arr[elem][0] for elem in range(x)] if y==1 else arr[0]#只有一列
        #存储要输出的内容
        cycle_list=[]
        #最上横行
        for i in range(y):cycle_list.append(arr[0][i])
        #最右竖列
        for i in range(x-1):cycle_list.append(arr[i+1][y-1])
        #最下横行(逆过来)
        for i in range(y-1):cycle_list.append(arr[x-1][y-i-2])
        #最左竖列(逆过来)
        for i in range(x-2):cycle_list.append(arr[x-i-2][0])
        #中间剩下的矩阵(递归)
        arr_inside=[]
        for i in range(x-2):
            arr_inside.append([])
            for j in range(y-2):arr_inside[i].append(arr[i+1][j+1])
        cycle_list+=Solution.printMatrix(self, arr_inside)
        return cycle_list
还以为自己的方法还行,结果看了大佬们的觉得我这个就是垃圾
思路是这样的,把矩阵外围一圈(上右下左)输出,然后递归输出被包围的矩阵
发表于 2019-03-06 18:57:25 回复(0)
python最易理解解法
每次都取,并删除第一行,然后逆时针旋转矩阵,直到矩阵为空,这里矩阵旋转使用了zip函数
class Solution:
    def printMatrix(self, matrix):
        res = []
        while matrix:
            tmp = matrix.pop(0)
            res += tmp
            matrix = zip(*matrix)[::-1]
        return res

发表于 2019-02-25 16:52:37 回复(0)

扫一扫,把题目装进口袋

牛客网,程序员必备求职神器

扫描二维码,进入QQ群

扫描二维码,关注牛客网公众号