20 顺时针打印数组

最新推荐文章于 2022-05-22 10:54:23 发布

原创最新推荐文章于 2022-05-22 10:54:23 发布 · 178 阅读

0 ·

CC 4.0 BY-SA版权

剑指offer 专栏收录该内容

62 篇文章

订阅专栏

本文详细解析了矩阵螺旋打印算法的实现过程，包括整体思路、边界条件及难点处理。通过具体示例说明如何按螺旋顺序打印矩阵元素，并针对不同边界情况提供了解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

import java.util.ArrayList;

public class T20 {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList list = new ArrayList();
        int rows = matrix.length;
        int cols = matrix[0].length;
        if(matrix == null || rows == 0 || cols == 0)
            return list;

        int start = 0;
        while(start * 2 < (Math.min(cols,rows))){
            printm(matrix,rows,cols,start,list);
            start++;
        }

        return list;
    }

    private void printm(int[][] matrix, int rows, int cols, int start, ArrayList list) {
        int endX = cols -1 - start;
        int endY = rows - 1 - start;

        //从左往右，一行
        for(int i=start;i<=endX;i++){
            list.add(matrix[start][i]);
        }

        //从上向下打印一列,前提是：结束的那一列---终止行号大于开始行号
        if(endY > start){
            for(int i=start+1;i<=endY;i++){
                list.add(matrix[i][endX]);
            }
        }

        //从右向左打印一行   前提是：终止列号大于起始列号（至少两列），并且不能是一行（至少两行），即：终止行号大于起始行号
        if(endY > start && endX > start){
            for(int i=endX-1;i>=start;i--){
                list.add(matrix[endY][i]);
            }
        }

        //从下向上打印一列   ==》至少三行两列  终止列号大于起始列号（至少2列 ，保证横着打印过了）   终止行号比起始行号大2  （至少3行）
        if (endX > start && endY - 1 > start){
            for(int i=endY-1;i>start;i++){
                list.add(matrix[i][start]);
            }
        }
    }
}

import java.util.ArrayList;
public class Solution {
    public void print(int [][] matrix,int rows,int cols,int k, ArrayList<Integer> arr) {                    
            int endX = cols-1-k;
            int endY = rows-1-k;

            for(int j=k;j<=endX;j++)
                arr.add(matrix[k][j]);
            for(int j=k+1;j<=endY;j++)
                arr.add(matrix[j][endX]);
            if(k < endX && k < endY){//eg：一行或者一列
                for(int j=endX-1;j>=k;j--)
                    arr.add(matrix[endY][j]);     
            }
            if(k < endX && k < endY-1){
                for(int j=endY-1;j>k;j--)
                    arr.add(matrix[j][k]);    
            }                        
     }
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> arr = new ArrayList();
        int rows = matrix.length;
        int cols = matrix[0].length;
        if(rows == 1 && cols == 1){
            arr.add(matrix[0][0]);
            return arr;
        }
        int i = 0,j = 0;
        int k = 0;                       
        while(k * 2 < (Math.min(rows,cols))){
            print(matrix,rows,cols,k,arr);
            k++;          
        }
        return arr;
    }
}

1、整体思路
设矩阵为m行n列，那么第一圈：
（1）从左到右（0，0）–>（0，n-1）【包含这一行的最后一个节点】

（2）从上到下 (1,n-1) —->(m-1,n-1) 【包含这一列的最后一个节点】

（3）从右到左 (m-1,n-2)—>(m-1,0) 【包含这一行的第一个节点】

（4）从下到上 (m-2,0)—->(1,0) 【包含这一列的第2个节点 =》最短】

第二圈开始的节点为（1，1）；第三圈有的话为（2，2）；==》每一圈开始的坐标：（start，start）
如果是5行5列的话，最后一个就是（2，2）。所以圈的次数*2和行和列的个数相关。
==》终结条件：k * 2 < (Math.min(rows,cols))

2、边界条件==>如何打印一圈？
重点：每一步的起始坐标。
难点：最后一圈可能退化为一行、一列、两行或是一个点。这样的话，就不再需要四步了。
第一步总是需要的，因为打印一圈至少一步（一个点或者一行）；
需要第二步的前提是终止行号大于起始行号。
需要第三步的前提是至少两行两列，即除了要求终止行号大于起始行号之外，还要求终止列号大于起始列号，；
需要第四步的前提是：至少三行两列，因此要求终止行号比起始行号至少大2，同时终止列号大于起始列号。

能用乘法的用乘法，尽量不用除法！
print（）函数中有两个难点：
（1）上下左右的交界点，容易被重复打印；
（2）终止行号和列号与k的关系
等以后再回复一遍吧

参考：
https://blog.youkuaiyun.com/qq_33724710/article/details/51392553
https://blog.youkuaiyun.com/lilianforever/article/details/51848885