首页 > 试题广场 > 顺时针打印矩阵
[编程题]顺时针打印矩阵
输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下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.
推荐
/*解题思路:顺时针打印就是按圈数循环打印,一圈包含两行或者两列,在打印的时候会出现某一圈中只包含一行,要判断从左向右打印和从右向左打印的时候是否会出现重复打印,同样只包含一列时,要判断从上向下打印和从下向上打印的时候是否会出现重复打印的情况*/
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 回复(47)
python答案,看起来代码很多,但是很容易理解,另外提交很多次不过看了大家的答案才知道需要返回一个列表,并不是在函数中直接打印
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        if not matrix:
            return []
        res = []
        x = len(matrix)
        y = len(matrix[0])
        #print(x,y)
        sx = 0
        ex = x - 1
        sy = 0
        ey = y - 1
        while (sx < ex and sy < ey):
            for i in range(sy, ey + 1):
                res.append(matrix[sx][ i])
            for i in range(sx + 1, ex + 1):
                res.append(matrix[i][ ey])
            for i in range(ey - 1, sy - 1, -1):
                res.append(matrix[ex][i])
            for i in range(ex - 1, sx, -1):
                res.append(matrix[i][sy])
            sx += 1
            sy += 1
            ex -= 1
            ey -= 1
        if sx == ex and sy <= ey:
            for i in range(sy, ey + 1):
                res.append(matrix[sx][i])
        elif sx <= ex and sy == ey:
            for i in range(sx, ex + 1):
                res.append(matrix[i][sy])
        return res
发表于 2019-08-17 10:36:45 回复(0)
顺时针打印的操作包括维持打印方向和判断方向是否改变。
假设当前点位置为(i,j),打印方向为(i_,j_),则当前点标记为matrix[i][j]='o'。参数更新为 i, j = i+i_, j+j_. 判断,若是,则改变打印方向,打印方向方式如下为:;否则,则保持打印方向不变。直到打印到第m*n个元素停止。
代码如下:
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        L = list()
        m = len(matrix)
        n = len(matrix[0])
        num = m*n
        count = 0
        i,j=0,-1
        i_,j_ = 0,1
        while count < num:
            i,j,i_,j_ = self.ref( i,j,i_,j_,m,n,matrix )
            L += [matrix[i][j]]
            matrix[i][j] = 'o'
            count += 1
        return L
    
    def ref(self, i, j, i_, j_, m, n, matrix):
        i,j=i+i_,j+j_
        r,c = max(0,min(i,m-1)),max(0,min(j,n-1))
        if matrix[r][c]=='o':
            if i_==0 and j_==1:
                i_,j_ = 1,0
                i,j = i+i_,j+j_-1
            elif i_==1 and j_==0:
                i_,j_=0,-1
                i,j=i+i_-1,j+j_
            elif i_==0 and j_==-1:
                i_,j_=-1,0
                i,j=i+i_,j+j_+1
            elif i_==-1 and j_==0:
                i_,j_=0,1
                i,j=i+i_+1,j+j_
        return i,j,i_,j_


发表于 2019-08-16 17:42:11 回复(0)
使用python,在如何判断是一维数组处纠结了很久,最后使用了判断int的方法,然后使用分类别来进行输出,详细思路见答案
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        res=[]
        rows=len(matrix)
        #判断是否是一维列表
        if type(matrix[0]) is int:
            for i in range(rows):
                res.append(matrix[i])
            return
        else:
            columns=len(matrix[0])
        start=0
        while rows>start*2 and columns>start*2:
            
            endX=columns-1-start
            endY=rows-1-start
            #step1
            for i in range(start,endX+1):
                res.append(matrix[start][i])
                
            #2steps
            if start<endY:
                for j in range(start+1,endY+1):
                    res.append(matrix[j][endX])
            #3steps
            if start<endY and start<endX:
                i=endX-1
                while i>=start:
                    res.append(matrix[endY][i])
                    i=i-1
            #4steps
            if start<endY-1 and start<endX:
                j=endY-1
                while j>start:
                    res.append(matrix[j][start])
                    j=j-1
            start=start+1
        return res
       

发表于 2019-08-06 23:48:50 回复(0)
一定要弄清楚每次循环的范围以及弄清行还是列在变化。
发表于 2019-08-01 21:06:22 回复(0)
所有情况均有第一行
行数>=3下都有第二列,要刨去头尾
行数>=2下都有第二行
行数>=3且列数>=2下都有第一行,要刨去头尾
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result = []
        row = len(matrix)
        col = len(matrix[0])
        i = 0
        while 2*i < row and 2*i < col:
            result.extend(matrix[i][i : col-1 -i +1])
            if row-1 -i - i > 1: # 如果大于等于3行
                for ri in range(i+1, row-1 -i):
                    result.append(matrix[ri][col-1 -i])
            if row-1-i -i >= 1:
                result.extend(matrix[row-1-i][i : col-1 -i+1][::-1])
            if row-1 -i - i > 1 and col-1 -i - i >= 1:
                for ri in range(row-1 -i-1, i, -1):
                    result.append(matrix[ri][i])
            i += 1
        return result
        '''
        circle = []
        row = len(matrix)
        col = len(matrix[0]) 
        r_i = 0
        while 2*(r_i) < row and 2*(r_i) < col:
            circle.extend(matrix[r_i][r_i:col-r_i]) # 打印第一行 
            if row-2*(r_i+1) > 0: # 打印最后一列
                for i in range(r_i+1, row-1-r_i):  
                    circle.append(matrix[i][col-1-r_i])
            if row-2*(r_i+1) >= 0:
                circle.extend(matrix[row-1-r_i][r_i:col-r_i][::-1])  # 打印最后一行 
            if row-2*(r_i+1) > 0 and col-2*(r_i+1) >= 0:
                # circle.extend(matrix[r_i+1:row-1-r_i-1][r_i][::-1])  # 打印第一列
                for i in range(r_i+1, row-1-r_i)[::-1]:  
                    circle.append(matrix[i][r_i])
            r_i += 1
        return circle
        '''

发表于 2019-07-12 20:01:26 回复(0)
#每次输出第一行,然后将矩阵向左90°旋转,等到新的矩阵,依次操作,直到矩阵为空。
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result = []
        while matrix:
            result += matrix.pop(0)
            if matrix:
                matrix = self.rotate(matrix)
        return result
    def rotate(self, matrix):
        new_matrix =[]
        col = len(matrix[0])
        row = len(matrix)
        for i in range(col):
            new_line =[]
            for j in range(row):
                new_line.append(matrix[j][col-i-1])
            new_matrix.append(new_line)
        return new_matrix

发表于 2019-07-12 14:13:26 回复(0)
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        int row = matrix.size();
        int col = matrix[0].size();
        vector<int> result;
        if(row == 0 || col == 0)
            return result;
        int left = 0, right = col-1, top = 0, bottom = row-1;
        while(left <= right && top <= bottom){
            for(int i =left; i<=right; i++)
                result.push_back(matrix[top][i]);
            for(int i = top+1; i<=bottom;i++) // 注意这里的 i = top + 1
                result.push_back(matrix[i][right]);
            if(top!=bottom)
                for(int i =right-1;i>=left;i--)
                    result.push_back(matrix[bottom][i]);
            if(left!=right)
                for(int i = bottom-1;i>top;i--)
                    result.push_back(matrix[i][left]);
            left++;right--;top++;bottom--;
        }
        return result;
    }
};
-------------------------------------------------
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        ArrayList<Integer> result = new ArrayList<>();
        if(row == 0 || col == 0)
            return result;
        int left = 0, right=col-1,top=0,bottom = row-1;
        while(left <= right && top <= bottom){
            for(int i =left;i<=right;i++)
                result.add(matrix[top][i]);
            for(int i=top+1;i<=bottom;i++)
                result.add(matrix[i][right]);
            if(top!=bottom)
                for(int i = right-1;i>=left;i--)
                    result.add(matrix[bottom][i]);
            if(left!=right)
                for(int i =bottom-1;i>top;i--)
                    result.add(matrix[i][left]);
            left++;right--;top++;bottom--;
        }
        return result;
    }
}
---------------------------------------------------
# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result = []
        while(matrix):
            result += matrix.pop(0)
            if not matrix or not matrix[0]:
                break
            matrix = self.turnMatrix(matrix)
        return result
    def turnMatrix(self, matrix):#矩阵做逆时针旋转
        num_r = len(matrix)
        num_c = len(matrix[0])
        result  = []
        for i in range(num_c):
            tmp = []
            for j in range(num_r):
                tmp.append(matrix[j][i])
            result.append(tmp)
        result.reverse()
        return result

发表于 2019-07-10 19:49:03 回复(0)
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        return matrix and list(matrix.pop(0)) + self.printMatrix(zip(*matrix)[::-1])
        # write code here

发表于 2019-06-17 16:24:38 回复(0)
若matrix不为空,将matrix.pop(0)添加至列表,pop后的列表逆时针旋转90度,该操作用zip和列表逆序实现,循环至matrix为空,输出列表
class Solution:
    def printMatrix(self, matrix):
        out_list=[]
        while matrix:
            out_list+=matrix.pop(0)
            matrix = list(zip(*matrix))
            for i in range(len(matrix)):
                matrix[i] = list(matrix[i])
            matrix=matrix[::-1]
        return out_list

编辑于 2019-06-06 19:56:42 回复(0)
class Solution:
    # matrix类型为二维列表,需要返回列表
    def printMatrix(self, matrix):
        # write code here
        mSize=len(matrix)
        xSize=len(matrix[0])
        listR=[]
        listR.extend(matrix[0])
        #强化学习的概念,已经被用了,就不使用了,顺指针靠右走。
        for i in range(mSize*xSize):
            if len(listR)<mSize*xSize:
                matrix.__delitem__(0)
                self.rotate(matrix)
                listR.extend(matrix[0])
            else:
                break
        return listR

    def rotate(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: void Do not return anything, modify matrix in-place instead.
        """
        #matrix[:] = map(list,zip(*matrix[::-1]))
        matrix[:] = map(list, zip(*matrix))[::-1]
        #return matrix

        # return matrix
发表于 2019-05-27 17:09:37 回复(0)
    def printMatrix(self, matrix):
        res = []
        while matrix:
            # 第一行
            res.extend(matrix.pop(0))
            # 最后一列
            if matrix and matrix[0]:
                for row in matrix:
                    res.append(row.pop())
            # 最后一行
            if matrix:
                last_row = matrix.pop()
                res.extend(last_row[::-1])
            # 第一列
            if matrix and matrix[0]:
                for row in matrix[::-1]:
                    res.append(row.pop(0))
        return res
发表于 2019-05-09 15:15:27 回复(0)

# -*- coding:utf-8 -*- class Solution: # matrix类型为二维列表,需要返回列表  def printMatrix(self, matrix): # write code here  if len(matrix) == 0: return []
        printlist = []
        m = len(matrix)
        n = len(matrix[0]) if m == 1: for i in range(n):
                printlist.append(matrix[0][i]) return printlist elif n == 1: for i in range(m):
                printlist.append(matrix[i][0]) return printlist if min(m, n) & 1 == 0:
            curcle = min(m, n) >> 1  else:
            curcle = 1 + min(m, n) >> 1  for cur in range(curcle): for j in range(cur, n - cur):
                printlist.append(matrix[cur][j]) for k in range(1 + cur, m - cur):
                printlist.append(matrix[k][n - cur - 1]) for l in range(n - cur - 2, cur, -1): if m - 1 - 2 * cur != 0:
                    printlist.append(matrix[m - 1 - cur][l]) for q in range(m - cur - 1, cur, -1): if n - 1 - 2 * cur != 0:
                    printlist.append(matrix[q][cur]) return printlist

编辑于 2019-04-29 21:06:22 回复(0)

-- coding:utf-8 --

class Solution:

# matrix类型为二维列表,需要返回列表
def printMatrix(self, matrix):
    # write code here
    a=matrix
    n = 1
    b = []
    while (a and a[0]):
        if (n == 1):
            b.extend(a[0])
            a.remove(a[0])
        if (n == 2):
            for i in range(len(a)):
                m = len(a[i])
                b.append(a[i][m - 1])
                a[i][m-1] = ''
                a[i].remove('')
        if (n == 4):
            for i in range(len(a) - 1, -1, -1):
                b.append(a[i][0])
                a[i][0] = ''
                a[i].remove('')
        if (n == 3):
            m = a[len(a) - 1]
            for i in range(len(m)-1,-1,-1):
                b.append(m[i])
            a.remove(m)
        n = n + 1
        if (n > 4):
            n = n - 4
    return b
发表于 2019-04-20 16:58:05 回复(1)

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)