<source id="wwucw"><optgroup id="wwucw"></optgroup></source>
  • <option id="wwucw"><optgroup id="wwucw"></optgroup></option>
  • 首頁 > 試題廣場 > 順時針打印矩陣
    [編程題]順時針打印矩陣
    輸入一個矩陣,按照從外向里以順時針的順序依次打印出每一個數字,例如,如果輸入如下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.
    /*先打印第一行的數組元素,然后保存刪除第一行后的數組,再逆時針旋轉90°,如此往復,遞歸求出最后結果*/
    public class Solution {
    ????ArrayList<Integer> arrayList=new ArrayList<Integer>();
    ????public ArrayList<Integer> printMatrix(int [][] matrix)?
    ????{
    ????????if(matrix==null)return arrayList;
    ????????int n=matrix.length;//矩陣的行數
    ????????int m=matrix[0].length;//矩陣的列數
    ????????if(n>=1&&m==1)
    ????????{
    ????????????for(int i=0;i<n;i++)
    ????????????{
    ????????????????arrayList.add(matrix[i][m-1]);
    ????????????}
    ????????????return arrayList;
    ????????}
    ????????if(n==1&&m>=1)
    ????????{
    ????????????for(int i=0;i<m;i++)
    ????????????{
    ????????????????arrayList.add(matrix[n-1][i]);
    ????????????}
    ????????????return arrayList;
    ????????}
    ????????for(int j=0;j<m;j++)
    ????????{
    ????????????arrayList.add(matrix[0][j]);
    ????????}
    ????????int[][] mat=new int[n-1][m];
    ????????for(int i=0;i<n-1;i++)
    ????????{
    ????????????for(int j=0;j<m;j++)
    ????????????{
    ????????????????mat[i][j]=matrix[i+1][j];
    ????????????}
    ????????}
    ????????int[][] xuanzhuan=Rotation(mat, n-1, m);
    ????????return printMatrix(xuanzhuan);
    ? ? }
    ????public int[][] Rotation(int[][] mat,int n,int m)//逆時針旋轉90度
    ????{
    ????????int[][] a=new int[m][n];
    ????????for(int i=0;i<m;i++)
    ????????{
    ????????????for(int j=0;j<n;j++)
    ????????????{
    ????????????????a[i][j]=mat[j][m-i-1];
    ????????????}
    ????????}
    ????????return a;
    ????}
    ????public static void main(String[] args)
    ????{
    ????????int[][] a= {{1,2,3},{4,5,6},{7,8,9}};
    ????????Solution solution=new Solution();
    ????????Iterable<Integer> z=new ArrayList<Integer>();
    ????????z=solution.printMatrix(a);
    ????????System.out.println("*********************");
    ????????System.out.println("打印完整的arraylist元素:");
    ????????for(int x:z)
    ????????{
    ????????????System.out.print(x+" ");
    ????????}
    ????????System.out.println();
    ????}
    }


    發表于 今天 11:05:20 回復(0)
    更多回答
    推薦
    /*解題思路:順時針打印就是按
       查看全部
    編輯于 2015-09-07 13:31:21 回復(46)

    python solution:

    
    class Solution:
    
        def printMatrix(self, matrix):
            res = []
            while matrix:
                res += matrix.pop(0)
                if matrix and matrix[0]:
                    for row in matrix:
                        res.append(row.pop())
                if matrix:
                    res += matrix.pop()[::-1]
                if matrix and matrix[0]:
                    for row in matrix[::-1]:
                        res.append(row.pop(0))
            return res
    
    發表于 2017-10-13 21:42:14 回復(26)
    //很慚愧,編譯了多次才通過的代碼。。
    /*
        思想,用左上和右下的坐標定位出一次要旋轉打印的數據,一次旋轉打印結束后,往對角分別前進和后退一個單位。
        提交代碼時,主要的問題出在沒有控制好后兩個for循環,需要加入條件判斷,防止出現單行或者單列的情況。
     */
    class Solution {
    public:
        vector<int> printMatrix(vector<vector<int> > matrix) {
    		int row = matrix.size();
            int col = matrix[0].size();
            vector<int> res;
            
            // 輸入的二維數組非法,返回空的數組
            if (row == 0 || col == 0)  return res;
            
            // 定義四個關鍵變量,表示左上和右下的打印范圍
            int left = 0, top = 0, right = col - 1, bottom = row - 1;
            while (left <= right && top <= bottom)
            {
                // left to right
                for (int i = left; i <= right; ++i)  res.push_back(matrix[top][i]);
                // top to bottom
                for (int i = top + 1; i <= bottom; ++i)  res.push_back(matrix[i][right]);
                // right to left
                if (top != bottom)
                for (int i = right - 1; i >= left; --i)  res.push_back(matrix[bottom][i]);
                // bottom to top
                if (left != right)
                for (int i = bottom - 1; i > top; --i)  res.push_back(matrix[i][left]);
                left++,top++,right--,bottom--;
            }
            return res;
        }
    };

    編輯于 2015-08-29 23:32:18 回復(58)
    可以模擬魔方逆時針旋轉的方法,一直做取出第一行的操作
    例如?
    1 2 3
    4 5 6
    7 8 9
    輸出并刪除第一行后,再進行一次逆時針旋轉,就變成:
    6 9
    5 8
    4 7
    繼續重復上述操作即可。
    Python代碼如下

    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.turn(matrix)
            return result
        def turn(self,matrix):
            num_r = len(matrix)
            num_c = len(matrix[0])
            newmat = []
            for i in range(num_c):
                newmat2 = []
                for j in range(num_r):
                    newmat2.append(matrix[j][i])
                newmat.append(newmat2)
            newmat.reverse()
            return newmat
    編輯于 2016-08-16 20:09:28 回復(71)
    //主體循環部分才5行。其實是有規律可循的。將每一層的四個邊角搞清楚就可以打印出來了
    
    import java.util.ArrayList;
    public class Solution {
    ? ? public ArrayList<Integer> printMatrix(int [][] array) {
    ????????ArrayList<Integer> result = new ArrayList<Integer> ();
    ????????if(array.length==0) return result;
    ????????int n = array.length,m = array[0].length;
    ????????if(m==0) return result;
    ????????int layers = (Math.min(n,m)-1)/2+1;//這個是層數
    ????????for(int i=0;i<layers;i++){
    ????????????for(int k = i;k<m-i;k++) result.add(array[i][k]);//左至右
    ????????????for(int j=i+1;j<n-i;j++) result.add(array[j][m-i-1]);//右上至右下
    ????????????for(int k=m-i-2;(k>=i)&&(n-i-1!=i);k--) result.add(array[n-i-1][k]);//右至左
    ????????????for(int j=n-i-2;(j>i)&&(m-i-1!=i);j--) result.add(array[j][i]);//左下至左上
    ????????}
    ????????return result; ? ? ??
    ? ? }
    }
    

    編輯于 2015-06-22 00:41:47 回復(26)
    import java.util.ArrayList;
    public class Solution {
        ArrayList  a=new ArrayList();   new一個數組 以便下面函數能調用 
        public ArrayList printMatrix(int [][] matrix) {
           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--); 
            }
          return a;
        }
        public  void printEdge(int [][] m,int tR,int tC,int dR,int dC){
            if(tR==dR){    先判斷是否只是一橫行 如果是 打印該橫行的列(通常用于內圈)
                for(int i=tC;i<=dC;i++){
                    a.add(m[tR][i]);
                }
            }
            else if(tC==dC){  再判斷是否只是一豎列 如果是 打印該橫行的列(通常用于內圈
                for(int i=tR;i<=dR;i++){
                    a.add(m[i][tC]);
                }
            }
            else {
                int curC=tC;用2個變量儲存 用于判斷當前位置
                int curR=tR;
                while(curC!=dC){      當前位置未到達當前行的最右列 --》往右去
                    a.add(m[tR][curC]);
                curC++;
                }
                while(curR!=dR){      當前位置未到達當前列的最底行 --》往下去
                    a.add(m[curR][dC]);
                    curR++;
                }
                while(curC!=tC){      當前位置未到達當前行的最左列 --》往左去
                    a.add(m[dR][curC]);
                    curC--;
                }
                while(curR!=tR){      當前位置未到達當前列的最頂行 --》往上去
                    a.add(m[curR][tC]);
                    curR--;
                }
            }
        }
    }
    

    這個思路個人覺得看起來比上面的都要清晰 雖然較長 但是其實分析起來很簡單 ,就是一個剝圈的函數,這個函數 核心就是 左上點和右下點 每次走完剝圈函數之后 左上角坐標++,右下角-- 往圈內移 如果覺得好 可以點點頂上去 讓別人也看到

    發表于 2018-02-07 22:00:44 回復(12)
    順著走,即向右->向下->向左->向上,一共要走(長*寬)步。遇到邊界就改變方向,當向上碰到頂的時候,四個邊界都縮小。思路簡單,一個循環即可!

    class Solution {
    public:
        vector<int> printMatrix(vector<vector<int> > matrix) {
    		vector<int> ret;
            if(matrix.empty())return ret;
                
            int x,y,cnt=matrix[0].size()*matrix.size();
            int rEdge=matrix[0].size()-1,dEdge=matrix.size()-1,lEdge=0,uEdge=0;
            //bool first=true;
            for(x=0,y=0;cnt>0;cnt--){
    	    ret.push_back(matrix[x][y]);
                //;2
                //go  right
                if(x==uEdge){if(y<rEdge)y++;
                else if(y==rEdge){x++;}
                continue;}
                
                //down
                if(y==rEdge){if(x<dEdge)x++;
                else if(x==dEdge){y--;}
                continue;}
                
                //left
                if(x==dEdge){if(y>lEdge)y--;
                else if(y==lEdge){x--;}
                continue;}
                
                //up
                if(y==lEdge){if(x>uEdge+1)x--;
                else if( x==uEdge+1){y++;lEdge++;uEdge++;rEdge--;dEdge--;}
                continue;}
                //;3
            }
            return ret;
        }

    編輯于 2017-08-20 05:05:38 回復(6)
    沒做出來,我思路跟他們截然不同,他們什么意思我也沒看明白
    期望智商可以再上線一些
    -----------------------------------------------------------------------------------------
    updata20171008
    這道題其實蠻難的
    以第一種解法來說,不是眼見著一個for循環里面再包進去四個for循環那么簡單的;
    解決這道題里包含的一系列邏輯層次我現在整理、呈現出來如下:
    第一輪要理清的問題是:確定這個需求的具體實現過程是怎么樣的
    • 那也就是按照矩陣數據,一層層的畫圈出來
    • 那么這一畫整個需求實現過程也就清晰了:究竟哪一部分是變量,哪一部分是循環量
    第二輪要理清的問題也就出來了:從過程中確定出整個過程中的變量與循環量,這兩個量即構成了第一層循環
    第三輪要理清的問題就是確定第一層循環的循環主體,依然是回到需求的的實現過程中,在每一圈中都做了什么,也就是確定那四個循環
    第四輪,從數據攜帶的信息中挖掘出每一層循環主體所需要的判斷條件,這個最終是一組或幾組數學表達式
    對以上再進一步抽象,能得到類似問題的一般解決步驟,這里我再思考思考進行總結,暫時不寫在這里了。
    回到具體每一步的算法,首先就是要得到圈數:((row<col?row:col)-1)/2+1這個算式是怎么來的?
    • 很絕望的說,這個問題其實是難的,我前前后后想很久。。。具體思考是:
    1. 為什么獲取行列中最小的那個?嘗試著在矩陣上畫一個方形圈出來,只能以行/列中最小的為參考才能畫出一個圈,否則以最大的為參考這個圈是畫不出來的,因為最短邊不夠長
    2. 圈數到底怎么算的?所謂的圈其實是一個方形,那么很顯然只要有兩行或者兩列就得到一個圈,所以圈數=行or列/2。加一和減一是為了進行取舍。這里回頭我會上圖。
    得到了圈數后下一個難點就是從數據中挖掘出數學表達式成為每一層循環體的限定條件了
    1. 第一個層循環的限定條件就是圈數
    2. 第二層循環的限定條件是在圈數的基礎上得來的各條限定公式。此處需要上圖說明
    暫時先更新到這個地步吧,回頭還有第二種解法需要總結。淚目,就這么一道小題,其實超級耗費時間,因為密度很大,很多東西可以從中提煉到,所以其實是非常值得的。
    編輯于 2017-10-08 13:54:41 回復(7)
    /*
    		 * 采用旋轉魔方的方式 一次取一行,然后旋轉
    		 */
    		public ArrayList<Integer> printMatrix_2(int[][] matrix) {
    			ArrayList<Integer> al = new ArrayList<>();
    			int row = matrix.length;
    			while (row != 0) {
    				for (int i = 0; i < matrix[0].length; i++) {
    					al.add(matrix[0][i]);
    				}
    				if (row == 1)
    					break;
    				matrix = turn(matrix);
    				row = matrix.length;
    			}
    			return al;
    		}
    
    		private int[][] turn(int[][] matrix) {
    			// TODO 自動生成的方法存根
    			int col = matrix[0].length;
    			int row = matrix.length;
    			int[][] newMatrix = new int[col][row - 1];
    			for (int j = col - 1; j >= 0; j--) {
    				for (int i = 1; i < row; i++) {
    					newMatrix[col - 1 - j][i - 1] = matrix[i][j];
    				}
    			}
    			return newMatrix;
    		}
    
    
    
    public ArrayList<Integer> printMatrix_1(int[][] matrix) {
    			ArrayList<Integer> al = new ArrayList<>();
    			int row = matrix.length;
    			if (row == 0)
    				return al;
    			int col = matrix[0].length;
    			// 短的邊/2,向上取整
    			int circle = ((row > col ? col : row) + 1) / 2;
    			for (int i = 0; i < circle; i++) {
    
    				// 從左向右打印,j=i; j<col-i,
    				// 這一行的前i個已經在第i圈從下往上被打印,故j=i
    				// 倒數i個都已經在第i圈從上往下被打印,故j=col-i-1<col-i
    				for (int j = i; j < col - i; j++)
    					al.add(matrix[i][j]);
    
    				// 從上往下打印,j=i+1;j<row-i,
    				// 這一列的前i+1個已經在從左向右打印時被打印,故j=i+1
    				// 倒數i個已經在第i圈從右往左被打印,故j=row-i-1<row-i
    				for (int j = i + 1; j < row - i; j++)
    					al.add(matrix[j][col - i - 1]);
    
    				// 從右往左打印,j=col-i-2;j>=i&&row-i-1!=i;,
    				// 這一行倒數i個已經在第i圈從上往下被打印
    				// 這一行倒數第i+1個已經在從上往下時被打印,故j=col-1-(i+1)=col-i-2
    				// 這一行的前i個已經在從下往上時被打印,故j=i>=i
    				// 當第i圈為0時即從未由上往下打印時,col有多列時,會造成重復打印,故判斷row-i-1!=i以避免
    				for (int j = col - i - 2; j >= i && row - i - 1 != i; j--)
    					al.add(matrix[row - i - 1][j]);
    
    				// 從下往上打印,j=row-i-2;j>i&&col-i-1!=i,
    				// 這一列倒數i個已經在第i圈從右往作被打印
    				// 這一列倒數第i+1個已經在從右往左時被打印,故j=row-1-(i+1)=row-i-2
    				// 這一列的前i個已經在第i圈從左往右時被打印,
    				// 這一列的第i+1個已經在本圈從左往右被打印,故j=i+1>i
    				// 當第i圈為0時即從未由右向左打印時,row有多行時,會造成重復打印,故判斷col-i-1!=i以避免
    				for (int j = row - i - 2; j > i && col - i - 1 != i; j--)
    					al.add(matrix[j][i]);
    			}
    			return al;
    		}

    編輯于 2017-06-08 21:13:48 回復(2)
    1.每次都是一個圈,所以定義四個變量限定每次循環的界限:
      startRow,endRow,startCol,endCol;
    2.分別把首行,末列,末行,首列的數據依次加入list;
    3.注意不要重復加入某個點,每次都要限定界限。
    代碼如下:
        public ArrayList<Integer> printMatrix(int [][] matrix) {
    ???? ? ?int row = matrix.length;
    ???? ? ?if(row==0)
    ???? ? ?????return null;
    ???? ? ?int col = matrix[0].length;
    ???? ? ?if(col==0)
    ???? ? ?????return null;
    ???? ? ?ArrayList<Integer> list = new ArrayList<Integer>();
    ?????
    ???? ? ?int startRow = 0;
    ???? ? ?int endRow = row-1;
    ???? ? ?int startCol = 0;
    ???? ? ?int endCol = col-1;
    ???? ? ?while(startRow<=endRow&&startCol<=endCol){
    ???? ? ?????//如果就剩下一行
    ???? ? ?????if(startRow==endRow){
    ???????? ? ?????for(int i=startCol;i<=endCol;i++)
    ???????? ? ?????????list.add(matrix[startRow][i]);
    ???????? ? ?????return list;
    ???????? ? ?}
    ???? ? ?????//如果就剩下一列
    ???????? ? ?if(startCol==endCol){
    ???????? ? ?????for(int i=startRow;i<=endRow;i++)
    ???????? ? ?????????list.add(matrix[i][startCol]);
    ???????? ? ?????return list;
    ???????? ? ?}
    ???? ? ?????//首行
    ???? ? ?????for(int i=startCol;i<=endCol;i++)
    ???? ? ?????????list.add(matrix[startRow][i]);
    ???? ? ?????//末列
    ???? ? ?????for(int i=startRow+1;i<=endRow;i++)
    ???? ? ?????????list.add(matrix[i][endCol]);
    ???? ? ?????//末行
    ???? ? ?????for(int i=endCol-1;i>=startCol;i--)
    ???? ? ?????????list.add(matrix[endRow][i]);
    ???? ? ?????//首列
    ???? ? ?????for(int i=endRow-1;i>=startRow+1;i--)
    ???? ? ?????????list.add(matrix[i][startCol]);
    ???? ? ?????
    ???? ? ?????startRow = startRow + 1;
    ???? ? ?????endRow = endRow - 1;
    ???? ? ?????startCol = startCol + 1;
    ???? ? ?????endCol = endCol - 1;
    ???? ? ?}
    ???? ? ?return list;
    ? ? }
    

    編輯于 2017-12-04 21:42:49 回復(2)
    //借鑒的二樓的代碼,對二樓的代碼進行了部分判斷條件的修改
    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 top = 0, left = 0, right = col-1, bottom = row-1;
            
            while(top <= bottom && left<= right){
                //left to right
                for(int i = left; i <= right; ++i) result.push_back(matrix[top][i]);
                //top tp bottom
                for(int i = top+1; i <= bottom; ++i) result.push_back(matrix[i][right]);
                //right to left
                for(int i = right-1; i >= left && top < bottom; --i) result.push_back(matrix[bottom][i]);
                //bottom to top
                for(int i = bottom-1; i > top && right > left; --i) result.push_back(matrix[i][left]);
                ++top; ++left; --right; --bottom;
            }
            return result;
        }
    };

    發表于 2017-06-21 11:25:04 回復(9)
    /*
    * 1.選坐標為(0,0),(1,1)...的點記為(start,start)為開始坐標,下一圈開始坐標為(start+1,start+1)
    * 2.判斷是否進入下一圈(即是否打印完成)的條件是row>start*2 && column>start*2
    * 3.打印一圈的左上角坐標為(start,start),右下角的坐標為(column-start-1,row-start-1)
    * 4.根據一圈左上角和右下角坐標判斷“從左到右”,“從上到下”,“從右到左”,“從下到上”哪些用打印,哪些不用
    */
    
    class Solution {
    public:
        vector<int> printMatrix(vector<vector<int> > matrix) {
            if (matrix.empty()) {
                return matrix[0];
            }
            int row = static_cast<int>(matrix.size()) ;
            int column = static_cast<int>(matrix[0].size()) ;
            int start = 0;
            vector<int> result;
            result.clear();
            
            while (column > start*2 && row > start*2) {
                int endX = column - 1 - start;
                int endY = row - 1 - start;
                //從左到右打印一行
                for (int i=start; i<=endX; i++) {
                    result.push_back(matrix[start][i]);
                }
                //從上到下打印一行
                if (start <endY) {
                    for (int i=start+1; i<=endY; i++) {
                        result.push_back(matrix[i][endX]);
                    }
                }
                //從右到左打印一行
                if (start < endX && start < endY) {
                    for (int i=endX-1; i>=start; i--) {
                        result.push_back(matrix[endY][i]);
                    }
                }
                //從下到上打印一行
                if (start<endX && start<endY-1) {
                    for (int i=endY-1; i>=start+1; i--) {
                        result.push_back(matrix[i][start]);
                    }
                }
                start++;
            }
            return result;
        }
    };
    
    

    編輯于 2015-10-23 16:14:54 回復(8)
    人生苦短,我用python;
    用旋轉魔法的方式,一直取出第一行;
    例如
    1 2 3
    4 5 6
    7 8 9
    輸出并刪除第一行后,變為
    4 5 6
    7 8 9
    再進行一次逆時針旋轉,就變成:
    6 9
    5 8
    4 7
    繼續重復上述操作即可。
    編輯于 2016-09-04 16:02:53 回復(11)
    /**
     * @description 順時針打印矩陣
     * @author GongchuangSu
     * @since 2016.09.03
     * @explain 輸入一個矩陣,按照從外向里以順時針的順序依次打印出每一個數字,例如,如果輸入如下矩陣: 
     *                    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.
     */
    import java.util.*;
    
    public class Solution{
    	ArrayList<Integer> list = new ArrayList<>();
    	
        public ArrayList<Integer> printMatrix(int [][] matrix) {
        	int rows = matrix.length;
    		int columns = matrix[0].length;
    		int start = 0;
    		while(rows > start*2 && columns > start*2){
    			printMatrixInCircle(matrix, rows, columns, start);
    			start++;
    		}
            return list;
        }
    	
    	/**
    	 * 功能:打印一圈
    	 */
    	public void printMatrixInCircle(int [][] matrix, int rows, int columns, int start){
    		// 從左到右打印一行
    		for(int i = start; i < columns - start; i++)
    			list.add(matrix[start][i]);
    		// 從上到下打印一列
    		for(int j = start + 1; j < rows - start; j++)
    			list.add(matrix[j][columns - start - 1]);
    		// 從右到左打印一行
    		for(int m = columns - start - 2; m >= start && rows - start - 1 > start; m--)
    			list.add(matrix[rows - start - 1][m]);
    		// 從下到上打印一列
    		for(int n = rows - start - 2; n >= start + 1 && columns - start - 1 > start; n--)
    			list.add(matrix[n][start]);
    	}
    }
    
    
    發表于 2016-09-03 15:11:54 回復(12)
    前進,轉彎,...

    class Solution {
    ? ? int n, m;
    ? ? vector<vector<bool> > v;
    ? ? bool judge(int i, int j){
    ? ? ? ? return 0 <= i && i < n && 0 <= j && j < m && !v[i][j];
    ? ? }
    public:
    ? ? ?vector<int> printMatrix(vector<vector<int> > a) {
    ? ? ? ? vector<int> r;
    ? ? ? ? if(!(n = a.size()) || !(m = a[0].size())) return r;
            v = vector<vector<bool> >(n, vector<bool>(m, false));
    ? ? ? ? const int D[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    ? ? ? ? int i = 0, j = 0, d = 0, T = m * n;
    ? ? ? ? while(T--){
    ? ? ? ? ? ? r.push_back(a[i][j]);
    ? ? ? ? ? ? v[i][j] = true;
    ? ? ? ? ? ? if(!judge(i + D[d][0], j + D[d][1])) (++d) %= 4; //轉彎
    ? ? ? ? ? ? i += D[d][0], j += D[d][1];//前進
    ? ? ? ? }
    ? ? ? ? return r;
    ? ? }
    };

    編輯于 2017-05-17 19:23:43 回復(6)
    #打印第一行,刪除第一行,逆時針轉動90度。重復以上步驟,直到矩陣為空。 
    class Solution:
        def printMatrix(self, matrix):
            # write code here
            s=[]
            while matrix:
                s+=matrix[0]
                del matrix[0]
                matrix=zip(*matrix)[::-1]
            return s

    發表于 2017-07-10 17:55:07 回復(4)

    暴力 4個方向 右 下 左 上 依次循環

    class Solution {
    public:
        int dp[1000][1000];
        vector<int> printMatrix(vector<vector<int> > matrix) {
            int row = matrix.size(), col = matrix[0].size();
            int rs[] = {0, 1, 0, -1};
            int cs[] = {1, 0, -1, 0};
            memset(dp, 0, sizeof(dp));
            vector<int> ans;
            int dir = 0, r = 0, c = 0, step = row * col;
            while(step){
                step--; dp[r][c] = 1;
                ans.push_back(matrix[r][c]);
                if(r + rs[dir] >= row || r + rs[dir] < 0 || 
                   c + cs[dir] >= col || c + cs[dir] < 0 ||
                   dp[r + rs[dir]][c + cs[dir]]) dir = (dir + 1) % 4;
                r = r + rs[dir]; c = c + cs[dir];
            }
            return ans;
        }
    };
    
    發表于 2018-12-02 15:11:21 回復(0)
    class Solution {
    public:
        vector<int> printMatrix(vector<vector<int> > matrix) {		
            vector<int> v;         
            if(matrix.size()==0||matrix[0].size()==0)return v;
            int a=0,x=matrix.size()-1,y=matrix[0].size()-1,i,j;        
            do{
            for(i=a,j=a;j<=y;j++) v.push_back(matrix[i][j]);
            for(i=a+1,j=y;i<=x;i++) v.push_back(matrix[i][j]);
            if(a!=x)for(i=x,j=y-1;j>=a;j--) v.push_back(matrix[i][j]);
            if(a!=y)for(i=x-1,j=a;i>=a+1;i--) v.push_back(matrix[i][j]);
            }while(++a<=--x&&a<=--y);
            return v; 
        }
    };

    發表于 2015-08-07 17:05:39 回復(3)
    import java.util.ArrayList;
    public class Solution {
        public ArrayList<Integer> printMatrix(int [][] matrix) {
           ArrayList<Integer> ls = new ArrayList<Integer>();
    		int colStart = 0;
    		int colEnd = matrix[0].length;
    
    		int lineStart = 0;
    		int lineEnd = matrix.length;
    		int count = lineEnd * colEnd;
    		if (matrix == null)
    			return ls;
    		while (count != 0) {
    			for(int i = colStart;i<colEnd;i++){
    				ls.add(matrix[lineStart][i]);
    				count--;
    			}
    			lineStart++;
    			if(count==0)
    				break;
    			for(int i = lineStart;i<lineEnd;i++){
    				ls.add(matrix[i][colEnd-1]);
    				count--;
    			}
    			colEnd--;
    			if(count==0)
    				break;
    			for(int i = colEnd-1;i>=colStart;i--){
    				ls.add(matrix[lineEnd-1][i]);
    				count--;
    			}
    			lineEnd--;
    			if(count==0)
    				break;
    			for(int i = lineEnd-1;i>=lineStart;i--){
    				ls.add(matrix[i][colStart]);
    				count--;
    			}
    			colStart++;
    			if(count==0)
    				break;
    		}
    		return ls;
        }
    }

    發表于 2016-06-30 17:20:49 回復(1)
    # -*- coding:utf-8 -*-
    class Solution:
    ? ? def printMatrix(self, matrix):
    ? ? ? ? result = []
    ? ? ? ? while matrix:
    ? ? ? ? ? ? result += matrix.pop(0)
    ? ? ? ? ? ? if matrix:
    ? ? ? ? ? ? ? ? matrix = [[row[col] for row in matrix] for col in reversed(range(len(matrix[0])))]? ? # 逆時針旋轉
    ? ? ? ? return result  
    發表于 2018-08-10 17:31:46 回復(1)

    題目描述

    題目描述
    輸入一個矩陣,按照從外向里以順時針的順序依次打印出每一個數字,例如,如果輸入如下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.

    解題思路

    旋轉打印有點難,不過也是有辦法的。我們可以把矩陣想象為一個魔方,我讀完第一行之后,我就把魔方左轉90度,再讀取第一行,這樣循環,直到最后一行結束。具體看代碼中注釋。

    我的答案

    
    /**************************
    用旋轉魔方的方式,一直取出第一行;
    
    例如
    
        1 2 3
        4 5 6
        7 8 9
    輸出并刪除第一行后,變為
    
        4 5 6
        7 8 9
    再進行一次逆時針旋轉,就變成:
    
        6 9
        5 8
        4 7
    繼續重復上述操作即可。
    ***************************/
    import java.util.ArrayList;
    public class Solution {
        public ArrayList<Integer> printMatrix(int [][] matrix) {
            //作為存放結果的容器
            ArrayList<Integer> list = new ArrayList<>();
            //拿到出事數組的行數
            int row = matrix.length;
    
            while(row != 0){
                //將數組的第一行先添加進容器中
                for(int i=0;i<matrix[0].length;i++)
                    list.add(matrix[0][i]);
                //當行數等于1時就沒有必要再繼續執行了,在上面打印完之后就可以停止了
                if(row == 1)
                    break;
                //刪除上面遍歷的數組的第一行,然后旋轉這個數組并返回
                matrix = revert(matrix);
                //更新行數
                row = matrix.length;
            }
    
            //返回
            return list;
        }
    
        private int[][] revert(int[][] matrix){
            //拿到matrix的行數和列數
            int rows = matrix.length;
            int cols = matrix[0].length;
    
            //因為我們要將原數組遍歷過的第一行刪除,然后旋轉變成一個新的數組,所以先初始化一下這個新數組
            int[][] newMatrix = new int[cols][rows-1];
    
            //對這個新數組進行賦值
            for(int j=cols-1;j>=0;j--){
                for(int i=1;i<rows;i++){
                    newMatrix[cols-j-1][i-1] = matrix[i][j];
                }
            }
    
            //返回新數組
            return newMatrix;
        }
    }
    編輯于 2019-03-07 19:55:58 回復(0)
    狠狠的撸2019手机看片电影最新版