顺时针打印矩阵如何实现?思路和实现分享java

KLQ 2020-04-29 10:47:39 java常见问答 4161

你知道顺时针打印矩阵java如何来实现吗?下面要给大家分享的就是这方面相关的内容,下面一起来了解一下思路和实现方式吧。

题目:

输入一个矩阵,依照从外向里以顺时针的顺序依次打印出每一个数字。

例:

假如输入以下4X4矩阵:

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。

思路1

代码实现:

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--;
            }
        }
    }
}

思路2

代码实现:

/*
 * 采用旋转魔方的方式 一次取一行,然后旋转
 */
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;
}

思路3:

一、 每次都是一个圈, 所以定义四个变量限定每次循环的界限:

startRow, endRow, startCol, endCol;

二、分别将首行, 末列, 末行, 首列的数据依次加入list;

三、注意不要重复加入某个点, 每次都要限定界限

代码实现:

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;
}

以上的几种思路和实现方式你都了解了吗?以上内容仅供参考。

更多相关内容,请继续关注奇Q工具网的java实例专栏了解。