Implementation of Clockwise Printing Matrix by java

This article example for everyone to share java to achieve clockwise printing matrix specific code, for your reference, the specific content is as follows

Title:

Enter a matrix to print out each number in a clockwise order from outside to inside. For example, if you enter the following matrix: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16, you will print out the numbers 1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10.

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 16

Method 1:

This paper introduces a matrix processing method: matrix cycle processing. In the matrix, the coordinates of the upper left corner (tR, tC) and the coordinates of the lower right corner (dR, dC) can represent a submatrix, such as the matrix in the title. When (tR, tC) = (0, 0), (dR, dC) = (3, 3), the submatrix represented is the whole matrix, then the outermost part of this submatrix is:

1 2 3 4

5 8

9 12

13 14 15 16

Print the outermost layer of this submatrix clockwise, and when (tR, tC) = (0, 0), (dR, dC) = (3, 3), the printed results are: 1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5. Next, when tR and tC are added by 1, dR and dC are subtracted by 1, respectively, that is, (tR, tC) = (1, 1), (dR, dC) = (2, 2), the submatrix at this time is:

6 7

10 11

Then print this matrix clockwise, and the result is 6, 7, 11, 10. Add 1 to tR and tC, and subtract 1 from dR and dC, that is, (tR, tC) = (2, 2), (dR, dC) = (1, 1). If the upper-left coordinates are to the right or below the lower-right coordinates (i.e. tR > dR ||tC > dC), stop and all results that have been printed are the required print results.

package Array;
 
import java.util.ArrayList;
import java.util.List;
 
public class spiralOrder {
 /**
 * @param matrix: a matrix of m x n elements
 * @return: an integer list
 */
 // Circular printing matrix 
 // Upper left corner point (tR,tC) , lower right corner (dR,dC)
 public List<Integer> spiralOrder(int[][] matrix) {
 // write your code here
 List<Integer> list=new ArrayList<>();
 if(matrix==null||matrix.length==0) return list;
 int dR=matrix.length-1;
 int dC=matrix[0].length-1;
 int tR=0;
 int tC=0;
 while(tR<=dR && tC<=dC ){
  PrintMatrix(matrix,list,tR++,tC++,dR--,dC--);
 }
 return list;
 }
 
 private void PrintMatrix(int[][] matrix,List<Integer> list,int tR,int tC,int dR,int dC){
 if(tR==dR){ //  Submatrix only 1 Row 
  for(int i=tC;i<=dC;i++)
  list.add(matrix[tR][i]);
 }else if(tC==dC){ //  Submatrix only 1 Column 
  for(int i=tR;i<=dR;i++)
  list.add(matrix[i][tC]);
 }else{
  int curC=tC;
  int curR=tR;
  while(curC!=dC){
  list.add(matrix[tR][curC]);
  curC++;
  }
  while(curR!=dR){
  list.add(matrix[curR][dC]);
  curR++;
  }
  while (curC!=tC){
  list.add(matrix[dR][curC]);
  curC--;
  }
  while(curR!=tR){
  list.add(matrix[curR][tC]);
  curR--;
  }
 }
 }
 
 public static void main(String[] args) {
 spiralOrder spiralOrder=new spiralOrder();
 int[][] matrix={};
 System.out.println(spiralOrder.spiralOrder(matrix));
 }
}

Method 2:

Analysis: If the upper left corner of the matrix is (0, 0), then the starting points of every 1 turn are (0, 0), (1, 1)... It can be observed that if the 2*2 matrix only prints 1 turn, the 3*3 matrix prints 2 turns, and the 3*2 matrix prints 1 turn, so there is col > count*2 & & row > count*2, count starts at 0.

For each turn of printing, the start line number and column number are count, the end line number endrow=row-1-count, and the end column number endcol=col-1-count.

Step 1 Printing from left to right is required, circulating with line numbers count and column numbers count incrementing through endrow.

Step 2 Printing from top to bottom satisfies the condition that the end line number is greater than the start line number endrow > count, circular printing, line number count+1 incremented through endrow, column number endcol.

Step 3 Print from right to left satisfies the condition that the end line number of step 2 is greater than the start line number endrow > count and the stop column number is greater than the start column number endcol > count, circular printing, line number endrow, column number endcol-1 to count decrement.

Step 4 Printing from bottom to top satisfies the condition that the end column number is greater than the start column number endcol > start and the end line number is at least 2 larger than the start line number, i.e. endrow-count > 1. Cyclic printing, line number endrow-1 to count+1 decreasing, column number count.

import java.util.ArrayList;
public class Solution {
 public ArrayList<Integer> result=new ArrayList<>();
 public ArrayList<Integer> printMatrix(int [][] matrix) {
  int row=matrix.length;
  int col=matrix[0].length;
  if(matrix==null || row<0 || col<0){
   return null;
  }
  int count=0;
  while(col>count*2 && row>count*2){
   PrintCircle(matrix,col,row,count);
   count++;
  }
  return result;
 }
 
 public void PrintCircle(int [][] matrix,int col,int row,int start){
  int endrow=row-start-1;
  int endcol=col-start-1;
  // Print from left to right 1 Row 
  // No. 1 1 Row 1 It will be printed 
  for(int i=start;i<=endcol;i++){
   result.add(matrix[start][i]);
  }
  // Print from top to bottom (the first 2 Step) 
  if(endrow>start){
   for(int i=start+1;i<=endrow;i++){
    result.add(matrix[i][endcol]);
   }
  }
  // Print from right to left 3 Step) 
  if(endrow>start && endcol>start){
   for(int i=endcol-1;i>=start;i--){
    result.add(matrix[endrow][i]);
   }
  }
  // Print from bottom to top 4 Step) 
  if((endrow-start>1)&&endcol>start){
   for(int i=endrow-1;i>=start+1;i--){
    result.add(matrix[i][start]);
   }
  }
 }
}