这是Cracking the Coding Interview的一个问题。解决方案说，程序旋转外部边缘，然后旋转内部边缘。但是，我在跟踪两个for循环的逻辑时遇到了麻烦。
有人可以解释代码的逻辑（例如，为什么他们这样做＆＃34;层＆lt; n / 2＆＃34;以及＆＃34; left - ＆gt; top＆＃34;和＆＃34的四个步骤;底部 - ＆gt;左边＆＃34;等）？另一方面，在编码面试中提出这个问题时，我们的思维过程会怎样？
给定由NxN矩阵表示的图像，其中每个像素都在 图像是4个字节，写一个方法将图像旋转90度。 你能这样做吗？
public static void rotate(int[][] matrix, int n) {
for (int layer = 0; layer < n / 2; ++layer) {
int first = layer;
int last = n - 1 - layer;
for(int i = first; i < last; ++i) {
int offset = i - first;
int top = matrix[first][i]; // save top
// left -> top
matrix[first][i] = matrix[last-offset][first];
// bottom -> left
matrix[last-offset][first] = matrix[last][last - offset];
// right -> bottom
matrix[last][last - offset] = matrix[i][last];
// top -> right
matrix[i][last] = top; // right <- saved top
}
}
}
答案 0 :(得分：38)
<强>概述
考虑样本矩阵可能如下所示：
ABCD
EFGH
IJKL
MNOP
出于解释的目的，ABCD被视为第0行，EFGH被视为第1行，依此类推。第0行的第一个像素是A.
另外，当我谈到外壳时，我指的是：
ABCD
E H
I L
MNOP
首先让我们看一下移动值的代码。
int top = matrix[first][i]; // save top
第一行将值缓存在顶部位置。这是指由[first] [i]标识的矩阵顶行上的位置。例如：保存A。
// left -> top
matrix[first][i] = matrix[last-offset][first];
下一部分将值从左侧位置移动到顶部位置。例如：取M并将其放在A所在的位置。
// bottom -> left
matrix[last-offset][first] = matrix[last][last - offset];
下一部分将值从底部位置移动到左侧位置。例如：取P并将其放在M所在的位置。
// right -> bottom
matrix[last][last - offset] = matrix[i][last];
下一部分将值从右侧位置移动到底部位置。例如：取D并将其放在P所在的位置。
// top -> right
matrix[i][last] = top; // right <- saved top
最后一部分将值从缓存（最高位置）移动到正确的位置。例如：从A所在的第一步开始D。
接下来的循环。
外部循环从第0行到总行数的一半。这是因为当您旋转第0行时，它也会旋转最后一行，当您旋转第1行时，它也会旋转倒数第二行，依此类推。
内循环从行中的第一个像素位置（或列）延伸到最后一个。请记住，对于第0行，这是从像素0到最后一个像素，但对于第1行，这是从像素1到倒数第二个像素，因为第一个和最后一个像素作为第0行的一部分旋转
因此外环的第一次迭代使外壳旋转。换句话说：
ABCD
EFGH
IJKL
MNOP
变为：
MIEA
NFGB
OJKC
PLHD
了解外壳如何顺时针旋转，但内芯未移动。
然后外循环的第二次迭代导致第二行旋转（不包括第一个和最后一个像素），最后得到：
MIEA
NJFB
OKGC
PLHD
答案 1 :(得分：5)
我正在写这个答案，因为即使在阅读了Jason上面发布的答案之后（这很好并且确实解决了我的几个问题），我仍然不清楚变量“offset”中扮演的角色是什么逻辑，所以花了几个小时来理解这一点，我想与大家分享。
这里使用了许多变量，了解每个变量的重要性非常重要。
如果你看变量'first'，它是无用的，它本质上是'layer'本身，'first'在整个逻辑中根本没有被修改。所以我删除了'first'变量（它可以工作，预读）。
为了理解内部for循环的每次迭代中每个值如何变化，我已经打印了这些变量的值。看看输出并了解当我们在内部for循环中从一个角移动到另一个角时哪些值会发生变化，这些值在遍历单个图层时保持不变，并且只有在我们更改图层时才会更改这些值。
内循环的一次迭代移动一个单独的块。 移动单个图层所需的迭代次数将随着我们向内移动而改变。变量'last'为我们完成了这项工作，它限制了内循环（限制内层并阻止我们超越shell，建立在Jason使用的命名法上）
研究输出的时间。
我使用过6x6矩阵。
Input:
315 301 755 542 955 33
943 613 233 880 945 280
908 609 504 61 849 551
933 251 706 707 913 917
479 785 634 97 851 745
472 348 104 645 17 273
--------------Starting an iteration of OUTER FOR LOOP------------------
--------------Starting an iteration of inner for loop------------------
layer =0
last =5
i =0
buffer = 315
offset = i-layer = 0
Current Status:
472 301 755 542 955 315
943 613 233 880 945 280
908 609 504 61 849 551
933 251 706 707 913 917
479 785 634 97 851 745
273 348 104 645 17 33
--------------Finished an iteration of inner for loop------------------
--------------Starting an iteration of inner for loop------------------
layer =0
last =5
i =1
buffer = 301
offset = i-layer = 1
Current Status:
472 479 755 542 955 315
943 613 233 880 945 301
908 609 504 61 849 551
933 251 706 707 913 917
17 785 634 97 851 745
273 348 104 645 280 33
--------------Finished an iteration of inner for loop------------------
--------------Starting an iteration of inner for loop------------------
layer =0
last =5
i =2
buffer = 755
offset = i-layer = 2
Current Status:
472 479 933 542 955 315
943 613 233 880 945 301
908 609 504 61 849 755
645 251 706 707 913 917
17 785 634 97 851 745
273 348 104 551 280 33
--------------Finished an iteration of inner for loop------------------
--------------Starting an iteration of inner for loop------------------
layer =0
last =5
i =3
buffer = 542
offset = i-layer = 3
Current Status:
472 479 933 908 955 315
943 613 233 880 945 301
104 609 504 61 849 755
645 251 706 707 913 542
17 785 634 97 851 745
273 348 917 551 280 33
--------------Finished an iteration of inner for loop------------------
--------------Starting an iteration of inner for loop------------------
layer =0
last =5
i =4
buffer = 955
offset = i-layer = 4
Current Status:
472 479 933 908 943 315
348 613 233 880 945 301
104 609 504 61 849 755
645 251 706 707 913 542
17 785 634 97 851 955
273 745 917 551 280 33
--------------Finished an iteration of inner for loop------------------
--------------Finished an iteration of OUTER FOR LOOP------------------
--------------Starting an iteration of OUTER FOR LOOP------------------
--------------Starting an iteration of inner for loop------------------
layer =1
last =4
i =1
buffer = 613
offset = i-layer = 0
Current Status:
472 479 933 908 943 315
348 785 233 880 613 301
104 609 504 61 849 755
645 251 706 707 913 542
17 851 634 97 945 955
273 745 917 551 280 33
--------------Finished an iteration of inner for loop------------------
--------------Starting an iteration of inner for loop------------------
layer =1
last =4
i =2
buffer = 233
offset = i-layer = 1
Current Status:
472 479 933 908 943 315
348 785 251 880 613 301
104 609 504 61 233 755
645 97 706 707 913 542
17 851 634 849 945 955
273 745 917 551 280 33
--------------Finished an iteration of inner for loop------------------
--------------Starting an iteration of inner for loop------------------
layer =1
last =4
i =3
buffer = 880
offset = i-layer = 2
Current Status:
472 479 933 908 943 315
348 785 251 609 613 301
104 634 504 61 233 755
645 97 706 707 880 542
17 851 913 849 945 955
273 745 917 551 280 33
--------------Finished an iteration of inner for loop------------------
--------------Finished an iteration of OUTER FOR LOOP------------------
--------------Starting an iteration of OUTER FOR LOOP------------------
--------------Starting an iteration of inner for loop------------------
layer =2
last =3
i =2
buffer = 504
offset = i-layer = 0
Current Status:
472 479 933 908 943 315
348 785 251 609 613 301
104 634 706 504 233 755
645 97 707 61 880 542
17 851 913 849 945 955
273 745 917 551 280 33
--------------Finished an iteration of inner for loop------------------
--------------Finished an iteration of OUTER FOR LOOP------------------
472 479 933 908 943 315
348 785 251 609 613 301
104 634 706 504 233 755
645 97 707 61 880 542
17 851 913 849 945 955
273 745 917 551 280 33
很抱歉，除了思考图层，i和偏移量的值如何变化以了解这里发生的事情之外别无他法。
最后代码
以下是我删除不必要的代码并添加所有打印语句的代码，以防有人想要玩更多内容。此代码还具有随机矩阵初始化和打印功能：
package com.crackingthecodinginterview.assignments.chap1;
public class Problem6RotateMatrix90 {
public static void main(String args[]){
int[][] matrix = new int[6][6];
initializeMatrix(matrix,6);
System.out.println("Input: ");
printMatrix(matrix,6);
rotate(matrix,6);
printMatrix(matrix,6);
}
public static void rotate(int[][] matrix, int n) {
for (int layer = 0; layer < n / 2; ++layer) {
System.out.println("\n--------------Starting an iteration of OUTER FOR LOOP------------------");
int last = n - 1 - layer;
for(int i = layer; i < last; ++i) {
int offset = i - layer;
int buffer = matrix[layer][i]; // save top
System.out.println("\n--------------Starting an iteration of inner for loop------------------");
System.out.println("layer ="+layer);
System.out.println("last ="+last);
System.out.println("i ="+i);
System.out.println("buffer = "+buffer);
System.out.println("offset = i-layer = "+ offset);
// left -> top
matrix[layer][i] = matrix[last-offset][layer];
// bottom -> left
matrix[last-offset][layer] = matrix[last][last - offset];
// right -> bottom
matrix[last][last - offset] = matrix[i][last];
// top -> right
matrix[i][last] = buffer; // right <- saved top
//print
System.out.println("Current Status: ");
printMatrix(matrix,6);
System.out.println("--------------Finished an iteration of inner for loop------------------");
}
System.out.println("--------------Finished an iteration of OUTER FOR LOOP------------------");
}
}
public static void printMatrix(int[][] matrix,int n){
System.out.print("\n");
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
System.out.print(" "+matrix[i][j]);
}
System.out.print("\n");
}
}
public static void initializeMatrix(int[][] matrix,int n){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
matrix[i][j]=(int) (Math.random() * 1000);
}
}
}
}
答案 2 :(得分：2)
刚才看到有一种更简单的方法可以通过重构“last - offset”来编写代码：
public static void rotateInPlace90DegreesClockwise(int[][] matrix) {
int n = matrix.length;
int half = n / 2;
for (int layer = 0; layer < half; layer++) {
int first = layer;
int last = n - 1 - layer;
for (int i = first; i < last; i++) {
int offset = i - first;
int j = last - offset;
int top = matrix[first][i]; // save top
// left -> top
matrix[first][i] = matrix[j][first];
// bottom -> left
matrix[j][first] = matrix[last][j];
// right -> bottom
matrix[last][j] = matrix[i][last];
// top -> right
matrix[i][last] = top; // right <- saved top
}
}
}
答案 3 :(得分：2)
检查此解决方案是否已就位。
public void rotateMatrix(Pixel[][] matrix) {
for (int i = 0; i < matrix.length / 2; i++) {
for (int j = 0; j < matrix.length - 1 - 2 * i; j++) {
Pixel tmp = matrix[j + i][matrix.length - 1 - i];
matrix[j + i][matrix.length - 1 - i] = matrix[i][j + i];
matrix[i][j + i] = matrix[matrix.length - 1 - j - i][i];
matrix[matrix.length - 1 - j - i][i] = matrix[matrix.length - 1 - i][matrix.length - 1 - j - i];
matrix[matrix.length - 1 - i][matrix.length - 1 - j - i] = tmp;
}
}
}
答案 4 :(得分：0)
简单的解决方案是：
int[][] a = { {00,01,02 }, { 10,11,12} ,{20,21,22}};
System.out.println(" lenght " + a.length);
int l = a.length;
for (int i = 0; i <l; i++) {
for (int j = l - 1; j >= 0; j--) {
System.out.println(a[j][i]);
}
}
答案 5 :(得分：0)
/**
* @param args
*/
public static void main(String[] args) {
int n = 5; //5x5 matrix
int[][] matrixInitial = initMatrix(n);
int[][] matrixFinal = rotate(matrixInitial, n);
System.out.println(matrixFinal.length);
int m = 4; //4x4 matrix
int[][] matrixInitial2 = initMatrix(m);
int[][] matrixFinal2 = rotate(matrixInitial2, m);
System.out.println(matrixFinal2.length);
}
private static int[][] rotate(int[][] matrixInitial, int n) {
//it is much like square layers. each layer will be read and rotated
int layerCount = (n + 1) / 2;
System.out.println("n: " + n + " layerCount: " + layerCount);
int[][] matrixFinal = new int[n][n];
if (n % 2 == 1) { // for odd # layers the centre does not move
matrixFinal[n / 2][n / 2] = matrixInitial[n / 2][n / 2];
layerCount -= 1;
}
for (int i = 0; i < layerCount; i++) {
int width = n - (2 * i); // width of the layer
System.out.println("width: " + width);
int[] top = new int[width]; // read top
for (int j = 0; j < width; j++) {
top[j] = matrixInitial[i][i + j];
}
System.out.println("top: " + Arrays.toString(top));
//OK TOP TO RIGHT
for (int j = 0; j < width; j++) { // move top to right
matrixFinal[j+i][width-1+i] = top[j];
}
int[] tempLeft = new int[width]; // left will be read backwards
for (int j = 0; j < width; j++) { // reverse the temp
tempLeft[j] = matrixInitial[i + j][i];
}
int[] left = new int[width];
int indexTemp = 0;
for (int j = width-1; j >= 0; j--) { // move temp to left
left[indexTemp++] = tempLeft[j];
}
System.out.println("left: " + Arrays.toString(left));
//OK LEFT TO TOP
for (int j = 0; j < width; j++) { // move left to top
matrixFinal[i][j + i] = left[j];
}
int[] bottom = new int[width]; read bottom
for (int j = 0; j < width; j++) {
bottom[j] = matrixInitial[width - 1 + i][j + i];
}
System.out.println("bottom: " + Arrays.toString(bottom));
//OK BOTTOM TO LEFT
for (int j = 0; j < width; j++) { // move bottom to left
matrixFinal[j+i][i] = bottom[j];
}
int[] tempRight = new int[width]; // right will be read backwards
for (int j = 0; j < width; j++) {
tempRight[j] = matrixInitial[j + i][width - 1 + i];
}
int[] right = new int[width]; //reverse the temp
int indexTemp2 = 0;
for (int j = width; j > 0; j--) {
right[indexTemp2++] = tempRight[j - 1];
}
System.out.println("right: " + Arrays.toString(right));
//OK RIGHT TO BOTTOM
for (int j = 0; j < width; j++) { // move right to bottom
matrixFinal[width-1+i][j + i] = right[j];
}
}
for (int i = 0; i < n; i++) {
System.out.println(Arrays.toString(matrixFinal[i]));
}
return matrixFinal;
}
private static int[][] initMatrix(int n) { // init the matrix
int[][] matrix = new int[n][n];
int fill = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
matrix[i][j] = fill++;
}
}
for (int i = 0; i < n; i++) {
System.out.println(Arrays.toString(matrix[i]));
}
System.out.println("******");
return matrix;
}
答案 6 :(得分：0)
这是我在JavaScript中的解决方案，它在从右上角开始的行和列之间交换值，向内移动，直到交换最左下角的对。
function rotateMatrix(arr) {
var n = arr.length - 1;
for (var i = 0; i < n; i++) {
for (var j = 0; j < n - i; j++) {
var temp = arr[i][j];
arr[i][j] = arr[n - j][n - i]; // top row
arr[n - j][n - i] = temp; // right column
}
}
return arr;
}
答案 7 :(得分：0)
这是一个非常适合我的简单解决方案。
private int[][] rotateMatrix(int[][] matrix)
{
for(int i=0;i<matrix.length-1;i++)
{
for(int j =i;j<matrix[0].length;j++)
{
if(i!=j) {
int temp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = temp;
}
}
}
return matrix;
}
答案 8 :(得分：0)
是的，该代码非常难看且难以阅读-主要是因为作者没有使用非常具有描述性的变量名。我使用相同的原理解决了相同的问题（将正方形矩阵作为一组同心正方形，然后一次从外部正方形旋转到内部正方形）。这是我的解决方案以及对我思考过程的解释。
我使用了C＃，但是语法几乎与Java相同。复制/粘贴后，只需将a.Length更改为a.length，它在语法上应该是正确的Java。
void swap(int[][] a, int g, int h, int i, int j) {
int temp = a[g][h];
a[g][h] = a[i][j];
a[i][j] = temp;
}
int[][] rotateImage(int[][] a) {
if (a.Length > 1) {
int topRow = 0, bottomRow = a.Length - 1, leftCol = topRow, rightCol = bottomRow;
while (topRow < bottomRow && leftCol < rightCol) {
swap(a, topRow, leftCol, topRow, rightCol);
swap(a, topRow, leftCol, bottomRow, leftCol);
swap(a, bottomRow, leftCol, bottomRow, rightCol);
for (int i = topRow + 1, j = bottomRow - 1; i < bottomRow && j > topRow; i++, j--) {
swap(a, topRow, i, i, rightCol);
swap(a, topRow, i, bottomRow, j);
swap(a, topRow, i, j, leftCol);
}
topRow++; leftCol++;
bottomRow--; rightCol--;
}
}
return a;
}
您可能会注意到，由于变量leftCol和rightCol分别与topRow和bottomRow保持相等，因此我有可能摆脱它们。我之所以不这样做，是因为我认为它使代码更易于遵循。
首先，请注意，如果给定1x1矩阵，我们将返回原始矩阵，因为只有一个像素，这意味着不需要旋转。
接下来，假设我们得到以下2x2矩阵：
1 2
3 4
您可以按三个交换顺序旋转此矩阵。 Top Left -> Top Right，Top Left -> Bottom Left和Top Left -> Bottom Right。
4 1
2 3
现在想象一下，我们得到以下3x3矩阵：
1 2 3
4 5 6
7 8 9
请注意，内部正方形是我们的老朋友1x1矩阵。重要的是要认识到n > 1 && n % 2 != 0最终将在中心处减小到1x1的所有平方矩阵。同样，n > 1 && n % 2 == 0会缩小到中心2x2的那些位置。我们可以用相同的方式处理这两种情况。
同样，我们将从外部正方形的角开始。我们使用前面熟悉的三个交换：Top Left -> Top Right，Top Left -> Bottom Left和Top Left -> Bottom Right。
7 2 1
4 5 6
9 8 3
请注意，矩阵几乎旋转了；只是外部中心的四个讨厌的值。但是，还要注意，这些值中的每一个都离我们旋转的角只有一个位置。如果我们继续使用在拐角处使用固定起点的模式，则可以像这样旋转最后四个值：Top Middle -> Right Middle，Top Middle -> Bottom Middle和Top Middle -> Left Middle 。在索引方面，“中上”仅是“左上”加一。同样，“中右”只是“右上”加1。对于某些索引，从极大的索引（n - 1）开始递减是有意义的。我将较小的中间索引称为i，将较大的中间索引称为j。
7 4 1
8 5 2
9 6 3
需要三个交换来旋转2x2矩阵，六个交换要旋转3x3矩阵，并且通常需要n!交换来旋转nxn矩阵。我的while循环旋转矩阵中每个同心正方形的角（并且每个正方形小于前一个正方形），然后我的for循环处理沿着矩阵的角之间的值。边缘。像这样继续下去，直到没有更多的内部正方形可以旋转，或者剩下的唯一内部正方形是1x1矩阵。
答案 9 :(得分：0)
这是C＃中的解决方案。每个N x N矩阵都有底(N/2)个正方形周期。
例如-4×4和5×5都将具有2个可旋转的层。
以下角组合标识位置：
(top,left) points to (first,first) --> 0,0
(top,right) points to (first,last) --> 0,n
(bottom,left) points to (last,first) --> n,0
(bottom,right) points to (last,last) --> n,n
以下是将矩阵旋转90度的代码：
public static void RotateMatrixBy90Degress(int[][] matrix)
{
int matrixLen = matrix.Length;
for (int layer = 0; layer < matrixLen / 2; layer++)
{
int first = layer;
int last = matrixLen - first - 1;
for (int i = first; i < last; i++)
{
int offset = i - first;
int lastMinusOffset = last - offset;
// store variable in a temporary variable
int top = matrix[first][i];
// move values from left --> top
matrix[first][i] = matrix[lastMinusOffset][first];
// move values from bottom --> left
matrix[lastMinusOffset][first] = matrix[last][lastMinusOffset];
// move values from right --> bottom
matrix[last][lastMinusOffset] = matrix[i][last];
// move values from top --> right
matrix[i][last] = top;
}
}
}
这是在矩阵中生成随机数的代码。
public static void RotateMatrixImplementation(int len)
{
int[][] matrix = new int[len][];
var random = new Random();
for (int i = 0; i < matrix.Length; i++)
{
matrix[i] = new int[len]; // Create inner array
for (int j = 0; j < matrix[i].Length; j++)
{
//generate random numbers
matrix[i][j] = random.Next(1, Convert.ToInt32(Math.Pow(len, 3)));
}
}
RotateMatrixBy90Degress(matrix);
}
答案 10 :(得分：0)
这是我对这个问题的100％结果提交
首先，我将2D arraylist逐层分解为1D arrayList， 然后旋转一维矩阵 然后再次放入矩阵形式 将2D arraylist分解为1D arrayList时，我已经将元素的位置保存在array中 这样我们就可以将旋转矩阵放置在该位置
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;
public class Solution {
static List<Integer[]> storePosition = new ArrayList<>();
public static ArrayList<Integer> rotateOneDArray(List<Integer> arr, int K) {
int[] A = arr.stream().mapToInt(i -> i).toArray();
// write your code in Java SE 8
int r = K % (A.length);
int[] ans = new int[A.length];
int y;
for (int i = 0; i < A.length; i++) {
y = i - r;
if (y < 0) {
y += A.length;
}
ans[y] = A[i];
}
return (ArrayList<Integer>) Arrays.stream(ans).boxed().collect(Collectors.toList());
}
static ArrayList<ArrayList<Integer>> getLinearMatrix(List<List<Integer>> matrix) {
ArrayList<ArrayList<Integer>> linear = new ArrayList<ArrayList<Integer>>();
int M = matrix.get(0).size();
int N = matrix.size();
int m = M, n = N, i, j, counter = 0;
Integer[] pos = new Integer[2];
while (m >= 2 && n >= 2) {
i = counter;
j = counter;
ArrayList<Integer> list = new ArrayList<>((m + n - 2) * 2);
while (j < M - counter) {
list.add(matrix.get(i).get(j));
pos = new Integer[2];
pos[0] = i;
pos[1] = j;
storePosition.add(pos);
++j;
}
--j;
++i;
while (i < N - counter) {
list.add(matrix.get(i).get(j));
pos = new Integer[2];
pos[0] = i;
pos[1] = j;
storePosition.add(pos);
++i;
}
--i;
--j;
while (j >= counter) {
list.add(matrix.get(i).get(j));
pos = new Integer[2];
pos[0] = i;
pos[1] = j;
storePosition.add(pos);
--j;
}
++j;
--i;
while (i > counter) {
list.add(matrix.get(i).get(j));
pos = new Integer[2];
pos[0] = i;
pos[1] = j;
storePosition.add(pos);
--i;
}
linear.add(list);
++counter;
m -= 2;
n -= 2;
}
return linear;
}
// Complete the matrixRotation function below.
static void matrixRotation(List<List<Integer>> matrix, int r) {
int m = matrix.get(0).size();
int n = matrix.size();
ArrayList<ArrayList<Integer>> linearMat = getLinearMatrix(matrix);
ArrayList<ArrayList<Integer>> rotatedLinearMat = new ArrayList<ArrayList<Integer>>();
for (int f = 0; f < linearMat.size(); f++) {
rotatedLinearMat.add(f, rotateOneDArray(linearMat.get(f), r));
}
int p = 0;
Integer[][] result = new Integer[n][m];
for (int i = 0; i < rotatedLinearMat.size(); ++i) {
for (int j = 0; j < rotatedLinearMat.get(i).size(); ++j) {
result[storePosition.get(p)[0]][storePosition.get(p)[1]] = rotatedLinearMat.get(i).get(j);
++p;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
System.out.print(result[i][j] + " ");
}
System.out.println();
}
}
public static void main(String[] args) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String[] mnr = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");
int m = Integer.parseInt(mnr[0]);
int n = Integer.parseInt(mnr[1]);
int r = Integer.parseInt(mnr[2]);
List<List<Integer>> matrix = new ArrayList<>();
IntStream.range(0, m).forEach(i -> {
try {
matrix.add(
Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
.map(Integer::parseInt)
.collect(toList())
);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
});
matrixRotation(matrix, r);
bufferedReader.close();
}
}
答案 11 :(得分：0)
在这段代码中，您将能够旋转 NxN 矩阵一次，您也可以选择方向 1 表示顺时针，-1 表示相反。 在rotateMatrix 方法中，每个角都需要for-for 循环。
公共类 JavaApplication144 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int matrix[][] = {{56, 12, 8, 90, 40}, {87, 76, 99, 1, 32}, {34, 43, 25, 78, 6}, {39, 555, 65, 88, 3}, {44, 75, 77, 14, 10}};
print();
}
方法如下：
static int[][] shiftingmatris(int[][] p_matris, int dırectıon) {
int[][] tempmatris = new int[p_matris.length][p_matris[0].length];
if (dırectıon == -1) {
for (int i = 0; i < p_matris.length; i++) {
for (int j = 0; j < p_matris[0].length; j++) {
if (i == 0 && j != p_matris[0].length - 1) {
tempmatris[i][j + 1] = p_matris[i][j];
} else if (i == p_matris.length - 1 && j != 0) {
tempmatris[i][j - 1] = p_matris[i][j];
}
}
}
for (int i = 0; i < p_matris.length; i++) {
for (int j = 0; j < p_matris[0].length; j++) {
if (j == 0 && i != 0) {
tempmatris[i - 1][j] = p_matris[i][j];
} else if (j == p_matris[1].length - 1 && i != p_matris.length - 1) {
tempmatris[i + 1][j] = p_matris[i][j];
}
}
}
} else if (dırectıon == 1) {
for (int i = 0; i < p_matris.length; i++) {
for (int j = 0; j < p_matris[1].length; j++) {
if (i == 0 && j != 0) {
tempmatris[i][j - 1] = p_matris[i][j];
} else if (i == p_matris.length - 1 && j != p_matris[0].length - 1) {
tempmatris[i][j + 1] = p_matris[i][j];
}
}
}
for (int i = 0; i < p_matris.length; i++) {
for (int j = 0; j < p_matris[0].length; j++) {
if (j == 0 && i != p_matris.length - 1) {
tempmatris[i + 1][j] = p_matris[i][j];
} else if (j == p_matris[0].length - 1 && i != 0) {
tempmatris[i - 1][j] = p_matris[i][j];
}
}
}
}
for (int i = 1; i < p_matris.length - 1; i++) {
for (int j = 1; j < p_matris[1].length - 1; j++) {
tempmatris[i][j] = p_matris[i][j];
}
}
return tempmatris;
}
}
您还需要打印矩阵。可以通过这种方法：
public static void print(){
Scanner s = new Scanner(System.in);
System.out.println("times of rotate: ");
int dondurme = s.nextInt();
System.out.println("direction?");
int dırectıon = s.nextInt();
int matrix[][] = {{56, 12, 8, 90, 40}, {87, 76, 99, 1, 32}, {34, 43, 25, 78, 6}, {39, 555, 65, 88, 3}, {44, 75, 77, 14, 10}};
System.out.println(" ");
for (int i = 0; i < matrix.length; i++) {
System.out.println(" ");
for (int j = 0; j < matrix.length; j++) {
System.out.print(" ");
System.out.print(matrix[i][j] + " ");
}
}
for (int i = 0; i < dondurme; i++) {
matrix = shiftingmatris(matrix, dırectıon);
}
System.out.println(" ");
for (int i = 0; i < matrix.length; i++) {
System.out.println(" ");
for (int j = 0; j < matrix.length; j++) {
System.out.print(" ");
System.out.print(matrix[i][j] + " ");
}
}
}