blocks|key|148029|text|概述|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|148030|考虑一个示例矩阵，如下所示：|148031|ABCD
EFGH
IJKL
MNOP|code-block|syntax|javascript|148032|出于我的解释的目的，ABCD被认为是行0，EFGH是行1，依此类推。行0的第一个像素是A。|148033|另外，当我谈到外壳时，我指的是：|148034|ABCD
E++H
I++L
MNOP|148035|首先让我们看一下移动值的代码。|148036|++++int+top+=+matrix[first][i];+//+save+top|148037|第一行将值缓存在顶部位置。这是指由first标识的矩阵的顶行上的位置。例如:保存A。|CODE|148038|++++//+left+->+top
++++matrix[first][i]+=+matrix[last-offset][first];++++++++++|148039|下一部分将值从左侧位置移动到顶部位置。例如:将M放在A所在的位置。|148040|++++//+bottom+->+left
++++matrix[last-offset][first]+=+matrix[last][last+-+offset];+|148041|下一部分将值从底部位置移动到左侧位置。例如:将P放在M所在的位置。|148042|++++//+right+->+bottom
++++matrix[last][last+-+offset]+=+matrix[i][last];+|148043|下一部分将值从右侧位置移动到底部位置。例如:将D放在P所在的位置。|148044|++++//+top+->+right
++++matrix[i][last]+=+top;+//+right+<-+saved+top|148045|最后一部分将值从缓存(顶部位置)移动到正确的位置。例如:从D所在的第一步开始放置A。|148046|下一个循环。|148047|外部循环从第0行运行到总行数的一半。这是因为当您旋转第0行时，它也会旋转最后一行，而当您旋转第1行时，它也会旋转倒数第二行，依此类推。|148048|内部循环从行中的第一个像素位置(或列)运行到最后一个像素位置。请记住，对于行0，这是从像素0到最后一个像素，但是对于行1，这是从像素1到倒数第二个像素，因为第一个和最后一个像素是作为行0的一部分旋转的。|148049|因此，外部循环的第一次迭代会使外壳旋转。换句话说：|148050|148051|变成：|148052|MIEA
NFGB
OJKC
PLHD|148053|查看外壳如何顺时针旋转，但内核没有移动。|148054|然后，外部循环的第二次迭代导致第二行旋转(不包括第一个和最后一个像素)，我们最终得到：|148055|MIEA
NJFB
OKGC
PLHD|148056|entityMap^0|0|2|0|0|0|0|0|0|0|F|0|0|14|1|0|0|N|1|Q|1|0|0|N|1|Q|1|0|0|N|1|Q|1|0|0|T|1|14|1|0|0|6|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|23|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|24|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|25|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|26|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|27|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|28|8|@$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|U|3|V|5|J|7|2B|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|2C|8|@$9|2D|A|2E|B|Y]]|D|@]|E|$]]|$1|Z|3|10|5|J|7|2F|8|@]|D|@]|E|$K|L]]|$1|11|3|12|5|6|7|2G|8|@$9|2H|A|2I|B|Y]|$9|2J|A|2K|B|Y]]|D|@]|E|$]]|$1|13|3|14|5|J|7|2L|8|@]|D|@]|E|$K|L]]|$1|15|3|16|5|6|7|2M|8|@$9|2N|A|2O|B|Y]|$9|2P|A|2Q|B|Y]]|D|@]|E|$]]|$1|17|3|18|5|J|7|2R|8|@]|D|@]|E|$K|L]]|$1|19|3|1A|5|6|7|2S|8|@$9|2T|A|2U|B|Y]|$9|2V|A|2W|B|Y]]|D|@]|E|$]]|$1|1B|3|1C|5|J|7|2X|8|@]|D|@]|E|$K|L]]|$1|1D|3|1E|5|6|7|2Y|8|@$9|2Z|A|30|B|Y]|$9|31|A|32|B|Y]]|D|@]|E|$]]|$1|1F|3|1G|5|6|7|33|8|@$9|34|A|35|B|C]]|D|@]|E|$]]|$1|1H|3|1I|5|6|7|36|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|6|7|37|8|@]|D|@]|E|$]]|$1|1L|3|1M|5|6|7|38|8|@]|D|@]|E|$]]|$1|1N|3|I|5|J|7|39|8|@]|D|@]|E|$K|L]]|$1|1O|3|1P|5|6|7|3A|8|@]|D|@]|E|$]]|$1|1Q|3|1R|5|J|7|3B|8|@]|D|@]|E|$K|L]]|$1|1S|3|1T|5|6|7|3C|8|@]|D|@]|E|$]]|$1|1U|3|1V|5|6|7|3D|8|@]|D|@]|E|$]]|$1|1W|3|1X|5|J|7|3E|8|@]|D|@]|E|$K|L]]|$1|1Y|3|-4|5|6|7|3F|8|@]|D|@]|E|$]]]|1Z|$]]

Overview

Consider a sample matrix could look like this:

<pre><code>ABCD
EFGH
IJKL
MNOP
</code></pre>

For the purposes of my explanation, ABCD is considered as row 0, EFGH is row 1, and so on. The first pixel of row 0 is A.

Also, when I talk about the outer shell, I am referring to:

<pre><code>ABCD
E H
I L
MNOP
</code></pre>

First let's look at the code that moves the values.

<pre><code> int top = matrix[first][i]; // save top
</code></pre>

The first line caches the value in the top position. This refers to the position on the top row of the matrix identified by [first][i]. Eg: saving the <code>A</code>.

<pre><code> // left -&gt; top
 matrix[first][i] = matrix[last-offset][first]; 
</code></pre>

The next part moves the value from the left position into the top position. Eg: taking the <code>M</code> and putting it where the <code>A</code> is.

<pre><code> // bottom -&gt; left
 matrix[last-offset][first] = matrix[last][last - offset]; 
</code></pre>

The next part moves the value from the bottom position into the left position. Eg: taking the <code>P</code> and putting it where the <code>M</code> is.

<pre><code> // right -&gt; bottom
 matrix[last][last - offset] = matrix[i][last]; 
</code></pre>

The next part moves the value from the right position into the bottom position. Eg: taking the <code>D</code> and putting it where the <code>P</code> is.

<pre><code> // top -&gt; right
 matrix[i][last] = top; // right &lt;- saved top
</code></pre>

The last part moves the value from the cache (what was the top position) into the right position. Eg: putting the <code>A</code> from the first step where the <code>D</code> is.

Next the loops.

The outer loop runs from row 0 to half the total number of rows. This is because when you rotate row 0, it also rotates the last row and when you rotate row 1, it also rotates the second-to-last row, and so on.

The inner loop runs from the first pixel position (or column) in the row to the last. Keep in mind that for row 0, this is from pixel 0 to the last pixel, but for row 1, this is from pixel 1 to the second-to-last pixel, since the first and last pixels are rotated as part of row 0.

So the first iteration of the outer loop makes the outer shell rotate. In other words:

<pre><code>ABCD
EFGH
IJKL
MNOP
</code></pre>

becomes:

<pre><code>MIEA
NFGB
OJKC
PLHD
</code></pre>

See how the outer shell has rotated clockwise, but the inner core has not moved.

Then the second iteration of the outer loop causes the second row to rotate (excluding the first and last pixels) and we end up with:

<pre><code>MIEA
NJFB
OKGC
PLHD
</code></pre>

blocks|key|148075|text|我刚刚看到有一种通过重构"last+-offset“来编写代码的更简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|148076|public+static+void+rotateInPlace90DegreesClockwise(int[][]+matrix)+{
++++int+n+=+matrix.length;
++++int+half+=+n+/+2;

++++for+(int+layer+=+0;+layer+<+half;+layer%2B%2B)+{
++++++++int+first+=+layer;
++++++++int+last+=+n+-+1+-+layer;

++++++++for+(int+i+=+first;+i+<+last;+i%2B%2B)+{
++++++++++++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
++++++++}
++++}
}|code-block|syntax|javascript|148077|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just saw that there is a simpler way to write the code by refactoring &quot;last - offset&quot;:
<pre class="lang-java prettyprint-override"><code>public static void rotateInPlace90DegreesClockwise(int[][] matrix) {
 int n = matrix.length;
 int half = n / 2;

 for (int layer = 0; layer &lt; half; layer++) {
 int first = layer;
 int last = n - 1 - layer;

 for (int i = first; i &lt; last; i++) {
 int offset = i - first;
 int j = last - offset;
 int top = matrix[first][i]; // save top

 // left -&gt; top
 matrix[first][i] = matrix[j][first];

 // bottom -&gt; left
 matrix[j][first] = matrix[last][j];

 // right -&gt; bottom
 matrix[last][j] = matrix[i][last];

 // top -&gt; right
 matrix[i][last] = top; // right &lt;- saved top
 }
 }
}
</code></pre>

blocks|key|2728365|text|我之所以写这个答案，是因为即使读了上面Jason发布的答案(它很好，确实解决了我的几个问题)，我仍然不清楚变量“偏移”在这个逻辑中扮演的角色是什么，所以花几个小时来理解它，我想与每个人分享它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2728366|这里使用了许多变量，理解每个变量的重要性是很重要的。|2728367|如果你看一下变量'first'，它是没有用的，它本质上是‘层’本身，'first‘在整个逻辑中根本没有被修改。因此，我删除了'first‘变量(它可以工作，请提前阅读)。|2728368|为了理解这些值在内部for循环的每次迭代中是如何变化的，我打印了这些变量的值。看一看输出，了解当我们在内部for循环中从一个角落移动到另一个角落时，哪些值发生了变化，哪些值在遍历单个图层时保持不变，哪些值只有在我们改变图层时才发生变化。|2728369|内部循环的一次迭代会移动一个单独的块。当我们向内移动时，移动单层所需的迭代次数会发生变化。变量'last‘为我们完成了这项工作，它限制了内部循环(限制内部层并阻止我们超越shell，建立在Jason使用的命名法基础上)|2728370|研究输出的时间。|2728371|我使用了6x6矩阵。|2728372|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|code-block|syntax|javascript|2728373|抱歉，除了思考layer、I和offset的值如何变化之外，没有其他方法来理解这里到底发生了什么。|2728374|最后是代码|2728375|下面的代码中，我首先删除了不必要的内容，并添加了所有的print语句，以防有人想玩更多。此代码还具有随机矩阵初始化和打印功能：|2728376|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;+%2B%2Blayer)+{
++++++++++++System.out.println("\n--------------Starting+an+iteration+of+OUTER+FOR+LOOP------------------");

++++++++++++int+last+=+n+-+1+-+layer;
++++++++++++for(int+i+=+layer;+i+<+last;+%2B%2Bi)+{
++++++++++++++++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+="%2Blayer);

++++++++++++++++System.out.println("last+="%2Blast);
++++++++++++++++System.out.println("i+="%2Bi);

++++++++++++++++System.out.println("buffer+=+"%2Bbuffer);
++++++++++++++++System.out.println("offset+=+i-layer+=+"%2B+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%2B%2B){
++++++++++++for(int+j=0;j<n;j%2B%2B){
++++++++++++++++System.out.print("+"%2Bmatrix[i][j]);
++++++++++++}
++++++++++++System.out.print("\n");
++++++++}
++++}

++++public+static+void+initializeMatrix(int[][]+matrix,int+n){
++++++++for(int+i=0;i<n;i%2B%2B){
++++++++++++for(int+j=0;j<n;j%2B%2B){
++++++++++++++++matrix[i][j]=(int)+(Math.random()+*+1000);
++++++++++++}
++++++++}
++++}

}|2728377|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|19|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|1D|8|@]|9|@]|A|$Q|R]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

I'm writing this answer because even after reading the answer posted by Jason above (it's nice and did resolve a couple of questions I had) it still wasn't clear to me what role is variable "offset" playing in this logic, so spending a couple of hours to understand this I thought to share it with everyone.

There are many variables used here and it's important to understand the significance of each one.

If you look at the variable 'first', it's useless, it's essentially the 'layer' itself, 'first' isn't modified at all in the whole logic. So I have removed 'first' variable (and it works, read ahead). 

To understand how each of these values change in every iteration of the inner for loop I have printed the values of these variables. Take a look at the output and understand which values change when we move from one corner to another in the inner for loop, which values stay constant while traversing a single layer and which values change only when we change the layer. 

One iteration of inner loop moves one single block.
Number of iterations needed to move a single layer will change as we go inwards. The variable 'last' does that job for us, it restricts the inner loop (restricts the inner layer &amp; stops us from going beyond the shell, building upon the nomenclature Jason used)

Time to study the output. 

I have used 6x6 matrix.

<pre><code>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
</code></pre>

Sorry but there is no way other than to ponder upon how the values of layer, i and offset change to understand what the heck is happening here. 

Finally the code

Here is the code where I removed unnecessary first and added all the print statements, in case if anyone wants to play more. This code also has random matrix initialization and printing: 

<pre><code>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 &lt; n / 2; ++layer) {
 System.out.println("\n--------------Starting an iteration of OUTER FOR LOOP------------------");

 int last = n - 1 - layer;
 for(int i = layer; i &lt; 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 -&gt; top
 matrix[layer][i] = matrix[last-offset][layer]; 

 // bottom -&gt; left
 matrix[last-offset][layer] = matrix[last][last - offset]; 

 // right -&gt; bottom
 matrix[last][last - offset] = matrix[i][last]; 

 // top -&gt; right
 matrix[i][last] = buffer; // right &lt;- 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&lt;n;i++){
 for(int j=0;j&lt;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&lt;n;i++){
 for(int j=0;j&lt;n;j++){
 matrix[i][j]=(int) (Math.random() * 1000);
 }
 }
 }

}
</code></pre>

blocks|key|2940895|text|简单的解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2940896|int[][]+a+=+{+{00,01,02++},+{+10,11,12}+,{20,21,22}};
System.out.println("+lenght+"+%2B+a.length);

int+l+=+a.length;

for+(int+i+=+0;+i+<l;+i%2B%2B)+{

++++for+(int+j+=+l+-+1;+j+>=+0;+j--)+{
++++++++System.out.println(a[j][i]);
++++}
}|code-block|syntax|javascript|2940897|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The Simple solution is:

<pre><code>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 &lt;l; i++) {

 for (int j = l - 1; j &gt;= 0; j--) {
 System.out.println(a[j][i]);
 }
}
</code></pre>

blocks|key|150760|text|检查此解决方案以在适当位置执行此操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|150761|public+void+rotateMatrix(Pixel[][]+matrix)+{

++++for+(int+i+=+0;+i+<+matrix.length+/+2;+i%2B%2B)+{

++++++++for+(int+j+=+0;+j+<+matrix.length+-+1+-+2+*+i;+j%2B%2B)+{
++++++++++++Pixel+tmp+=+matrix[j+%2B+i][matrix.length+-+1+-+i];
++++++++++++matrix[j+%2B+i][matrix.length+-+1+-+i]+=+matrix[i][j+%2B+i];
++++++++++++matrix[i][j+%2B+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;
++++++++}
++++}
}|code-block|syntax|javascript|150762|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

check this solution to do it in place.

<pre><code>public void rotateMatrix(Pixel[][] matrix) {

 for (int i = 0; i &lt; matrix.length / 2; i++) {

 for (int j = 0; j &lt; 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;
 }
 }
}
</code></pre>

blocks|key|2728461|text|这是我在JavaScript中的解决方案，它从右上边缘开始在行和列之间交换值，一直向内直到交换了最左下角的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2728462|function+rotateMatrix(arr)+{
++++var+n+=+arr.length+-+1;

++++for+(var+i+=+0;+i+<+n;+i%2B%2B)+{
++++++++for+(var+j+=+0;+j+<+n+-+i;+j%2B%2B)+{
++++++++++++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;
}|code-block|syntax|javascript|2728463|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's my solution in JavaScript, it swaps values between a row and a column starting from the top-right edge, going inwards until the bottom-leftmost pair is swapped.

<pre><code>function rotateMatrix(arr) {
 var n = arr.length - 1;

 for (var i = 0; i &lt; n; i++) {
 for (var j = 0; j &lt; 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;
}
</code></pre>

blocks|key|2940976|text|这里有一个简单的解决方案，非常适合我。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2940977|+private+int[][]+rotateMatrix(int[][]+matrix)
++++{
++++++++for(int+i=0;i<matrix.length-1;i%2B%2B)
++++++++{
++++++++++++for(int+j+=i;j<matrix[0].length;j%2B%2B)
++++++++++++{
++++++++++++++++if(i!=j)+{
++++++++++++++++++++int+temp+=+matrix[i][j];
++++++++++++++++++++matrix[i][j]+=+matrix[j][i];
++++++++++++++++++++matrix[j][i]+=+temp;
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+matrix;
++++}|code-block|syntax|javascript|2940978|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a simple solution that works perfectly for me.

<pre><code> private int[][] rotateMatrix(int[][] matrix)
 {
 for(int i=0;i&lt;matrix.length-1;i++)
 {
 for(int j =i;j&lt;matrix[0].length;j++)
 {
 if(i!=j) {
 int temp = matrix[i][j];
 matrix[i][j] = matrix[j][i];
 matrix[j][i] = temp;
 }
 }
 }
 return matrix;
 }
</code></pre>

blocks|key|2728675|text|是的，这段代码很难看，也很难读--主要是因为作者没有使用描述性很强的变量名。我使用相同的原则解决了同样的问题(将方阵视为一组同心方块，然后一次旋转一个方块，从外部方块到内部方块)。这是我的解决方案和我的思维过程的解释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2728676|《守则》|2728677|我使用的是C#，但其语法几乎与Java相同。在复制/粘贴之后，只需将a.Length更改为a.length，它的语法应该是正确的。|offset|length|style|CODE|2728678|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+%2B+1,+j+=+bottomRow+-+1;+i+<+bottomRow+&&+j+>+topRow;+i%2B%2B,+j--)+{
++++++++++++++++swap(a,+topRow,+i,+i,+rightCol);
++++++++++++++++swap(a,+topRow,+i,+bottomRow,+j);
++++++++++++++++swap(a,+topRow,+i,+j,+leftCol);
++++++++++++}

++++++++++++topRow%2B%2B;+leftCol%2B%2B;
++++++++++++bottomRow--;+rightCol--;
++++++++}
++++}

++++return+a;
}|code-block|syntax|javascript|2728679|您可能会注意到，我可能会去掉变量leftCol和rightCol，因为它们分别与topRow和bottomRow相等。我不这样做的原因是因为我觉得这会让代码更容易理解。|2728680|解释|2728681|首先，请注意，如果给定一个1x1矩阵，我们将返回原始矩阵，因为只有一个像素，这意味着不需要旋转。|2728682|接下来，假设我们得到了以下2x2矩阵：|2728683|1+2
3+4|2728684|你可以在三次交换中旋转这个矩阵。Top+Left+->+Top+Right、Top+Left+->+Bottom+Left和Top+Left+->+Bottom+Right。|2728685|4+1
2+3|2728686|现在假设我们得到了下面的3x3矩阵：|2728687|1+2+3
4+5+6
7+8+9|2728688|请注意，内部正方形是我们的老朋友1x1矩阵。重要的是要认识到，所有方阵中的n+>+1+&&+n+%25+2+!=+0最终都会减少到中心的1x1。类似地，其中n+>+1+&&+n+%25+2+==+0将减少到中间的2x2。我们可以用同样的方式处理这两种情况。|2728689|同样，我们将从外部正方形的角落开始。我们使用我们熟悉的前三个交换：Top+Left+->+Top+Right、Top+Left+->+Bottom+Left和Top+Left+->+Bottom+Right。|2728690|7+2+1
4+5+6
9+8+3|2728691|请注意，矩阵几乎是旋转的；它只是外部边中心的那四个讨厌的值。但是，还要注意，这些值中的每个值都离我们旋转的角只有一个位置。如果我们继续我们的模式，对我们的掉期使用一个固定的起点，就像我们处理角落一样，我们可以像这样旋转最后四个值：Top+Middle+->+Right+Middle，Top+Middle+->+Bottom+Middle和Top+Middle+->+Left+Middle。在索引方面，“中上”只是“左上”加1。类似地，“右中间”就是“右上”加一。对于某些索引，从极大索引(n+-+1)开始并递减是有意义的。我将较小的中间索引称为i，将较大的中间索引称为j。|2728692|7+4+1
8+5+2
9+6+3|2728693|旋转2x2矩阵需要三次交换，旋转3x3矩阵需要六次交换，通常旋转nxn矩阵需要n!交换。我的while循环旋转矩阵中每个同心正方形的角(每个正方形都比前一个正方形小)，然后我的for循环处理沿边缘的角之间的值。这样继续下去，直到没有更多的内部正方形可以旋转，或者只剩下一个1x1矩阵。|2728694|entityMap^0|0|0|Y|8|19|8|0|0|G|7|O|8|14|6|1B|9|0|0|D|3|0|D|3|0|0|G|L|12|N|1Q|O|0|0|C|3|0|0|G|3|11|J|1U|3|24|J|2U|3|0|X|L|1J|N|27|O|0|0|37|Q|3Y|R|4Q|P|6U|5|7M|1|7Y|1|0|0|2|3|G|3|W|3|13|2|1A|5|2G|3|3S|3|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1L|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1M|8|@$F|1N|G|1O|H|I]|$F|1P|G|1Q|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1R|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1S|8|@$F|1T|G|1U|H|I]|$F|1V|G|1W|H|I]|$F|1X|G|1Y|H|I]|$F|1Z|G|20|H|I]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|21|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|22|8|@$F|23|G|24|H|I]]|9|@]|A|$]]|$1|U|3|V|5|6|7|25|8|@$F|26|G|27|H|I]]|9|@]|A|$]]|$1|W|3|X|5|L|7|28|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|29|8|@$F|2A|G|2B|H|I]|$F|2C|G|2D|H|I]|$F|2E|G|2F|H|I]]|9|@]|A|$]]|$1|10|3|11|5|L|7|2G|8|@]|9|@]|A|$M|N]]|$1|12|3|13|5|6|7|2H|8|@$F|2I|G|2J|H|I]]|9|@]|A|$]]|$1|14|3|15|5|L|7|2K|8|@]|9|@]|A|$M|N]]|$1|16|3|17|5|6|7|2L|8|@$F|2M|G|2N|H|I]|$F|2O|G|2P|H|I]|$F|2Q|G|2R|H|I]|$F|2S|G|2T|H|I]|$F|2U|G|2V|H|I]]|9|@]|A|$]]|$1|18|3|19|5|6|7|2W|8|@$F|2X|G|2Y|H|I]|$F|2Z|G|30|H|I]|$F|31|G|32|H|I]]|9|@]|A|$]]|$1|1A|3|1B|5|L|7|33|8|@]|9|@]|A|$M|N]]|$1|1C|3|1D|5|6|7|34|8|@$F|35|G|36|H|I]|$F|37|G|38|H|I]|$F|39|G|3A|H|I]|$F|3B|G|3C|H|I]|$F|3D|G|3E|H|I]|$F|3F|G|3G|H|I]]|9|@]|A|$]]|$1|1E|3|1F|5|L|7|3H|8|@]|9|@]|A|$M|N]]|$1|1G|3|1H|5|6|7|3I|8|@$F|3J|G|3K|H|I]|$F|3L|G|3M|H|I]|$F|3N|G|3O|H|I]|$F|3P|G|3Q|H|I]|$F|3R|G|3S|H|I]|$F|3T|G|3U|H|I]|$F|3V|G|3W|H|I]]|9|@]|A|$]]|$1|1I|3|-4|5|6|7|3X|8|@]|9|@]|A|$]]]|1J|$]]

Yes, that code is pretty ugly and hard to read - primarily because the author didn't use very descriptive variable names. I solved that same problem using the same principles (treating the square matrix as a set of concentric squares and then rotating one at a time going from the outer square to the inner square). Here is my solution and the explanation of my thought process.

<h1>The Code</h1>

I used C#, but the syntax is nearly identical to Java. After copy/pasting, just change <code>a.Length</code> to <code>a.length</code> and it should be syntactically correct Java.

<pre class="lang-cs prettyprint-override"><code>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 &gt; 1) {
 int topRow = 0, bottomRow = a.Length - 1, leftCol = topRow, rightCol = bottomRow;

 while (topRow &lt; bottomRow &amp;&amp; leftCol &lt; 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 &lt; bottomRow &amp;&amp; j &gt; 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;
}
</code></pre>

You may notice that I could potentially get rid of the variables <code>leftCol</code> and <code>rightCol</code> since they are kept equal to <code>topRow</code> and <code>bottomRow</code> respectfully. The reason that I don't is because I feel it makes the code easier to follow.

<h1>The Explanation</h1>

First, note that if given a <code>1x1</code> matrix, we return the original matrix because there is only one pixel which means no rotation is necessary.

Next, imagine we are given the following <code>2x2</code> matrix:

<pre><code>1 2
3 4
</code></pre>

You could rotate this matrix in three swaps. <code>Top Left -&gt; Top Right</code>, <code>Top Left -&gt; Bottom Left</code>, and <code>Top Left -&gt; Bottom Right</code>.

<pre><code>4 1
2 3
</code></pre>

Now imagine we are given the following <code>3x3</code> matrix:

<pre><code>1 2 3
4 5 6
7 8 9
</code></pre>

Note that the inner square is our old friend the <code>1x1</code> matrix. It's important to realize that all square matrices where <code>n &gt; 1 &amp;&amp; n % 2 != 0</code> will eventually reduce down to a <code>1x1</code> in the center. Similarly, those where <code>n &gt; 1 &amp;&amp; n % 2 == 0</code> will reduce down to a <code>2x2</code> in the center. We can handle both cases the same way.

Again, we will start with the corners of the outer square. We use our familiar previous three swaps: <code>Top Left -&gt; Top Right</code>, <code>Top Left -&gt; Bottom Left</code>, and <code>Top Left -&gt; Bottom Right</code>.

<pre><code>7 2 1
4 5 6
9 8 3
</code></pre>

Notice that the matrix is almost rotated; it's just those four pesky values in the centers of the exterior sides. But, also notice that each of those values are just one position away from the corners we rotated. If we continue our pattern of using a fixed starting point for our swaps the same way we did the corners, we could rotate the last four values like so: <code>Top Middle -&gt; Right Middle</code>, <code>Top Middle -&gt; Bottom Middle</code>, and <code>Top Middle -&gt; Left Middle</code>. In terms of indices, "Top Middle" is just "Top Left" plus one. Similarly, "Right Middle" is just "Top Right" plus one. For some of the indices, it makes sense to start at the extreme large index (<code>n - 1</code>) and decrement. I refer to the smaller middle index as <code>i</code> and the larger middle index as <code>j</code>.

<pre><code>7 4 1
8 5 2
9 6 3
</code></pre>

It takes three swaps to rotate a <code>2x2</code> matrix, six swaps to rotate a <code>3x3</code> matrix, and in general it takes <code>n!</code> swaps to rotate a <code>nxn</code> matrix. My <code>while</code> loop rotates the corners for each concentric square in the matrix (and each square is smaller than the previous square), and then my <code>for</code> loop takes care of the values in-between the corners along the edges. It continues like this until either there are no more interior squares to rotate, or the only interior square remaining is a <code>1x1</code> matrix.

blocks|key|2941223|text|以下是C#中的解决方案。每个N+x+N矩阵都有floor+(N/2)平方循环。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2941224|例如-+4×4和5×5都将有两个可旋转的层。|2941225|下面的角点组合标识位置：|2941226|(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|code-block|syntax|javascript|2941227|下面是将矩阵旋转90度的代码：|2941228|public+static+void+RotateMatrixBy90Degress(int[][]+matrix)+{
++++int+matrixLen+=+matrix.Length;
++++for+(int+layer+=+0;+layer+<+matrixLen+/+2;+layer%2B%2B)+{
++++++++int+first+=+layer;
++++++++int+last+=+matrixLen+-+first+-+1;

++++++++for+(int+i+=+first;+i+<+last;+i%2B%2B)+{
++++++++++++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;
++++++++}
++++}
}|2941229|这是在矩阵中生成随机数的代码。|2941230|public+static+void+RotateMatrixImplementation(int+len)+{
++++int[][]+matrix+=+new+int[len][];
++++var+random+=+new+Random();
++++for+(int+i+=+0;+i+<+matrix.Length;+i%2B%2B)+{
++++++++matrix[i]+=+new+int[len];+//+Create+inner+array
++++++++for+(int+j+=+0;+j+<+matrix[i].Length;+j%2B%2B)+{
++++++++++++//generate+random+numbers
++++++++++++matrix[i][j]+=+random.Next(1,+Convert.ToInt32(Math.Pow(len,+3)));
++++++++}
++++}
++++RotateMatrixBy90Degress(matrix);
}|2941231|entityMap^0|E|5|T|5|0|4|3|8|3|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|19|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1B|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|1D|8|@]|D|@]|E|$M|N]]|$1|W|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|X|$]]

Here's the solution in C#. Every <code>N x N</code> matrix will have floor <code>(N/2)</code> square cycles.
For e.g. - Both <code>4×4</code> &amp; <code>5×5</code> will have 2 rotatable layers.
Following corner-combination identifies the positions:
<pre><code>(top,left) points to (first,first) --&gt; 0,0
(top,right) points to (first,last) --&gt; 0,n
(bottom,left) points to (last,first) --&gt; n,0
(bottom,right) points to (last,last) --&gt; n,n
</code></pre>
Here's the code to rotate matrix by 90 degrees:
<pre class="lang-java prettyprint-override"><code>public static void RotateMatrixBy90Degress(int[][] matrix) {
 int matrixLen = matrix.Length;
 for (int layer = 0; layer &lt; matrixLen / 2; layer++) {
 int first = layer;
 int last = matrixLen - first - 1;

 for (int i = first; i &lt; 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 --&gt; top
 matrix[first][i] = matrix[lastMinusOffset][first];

 // move values from bottom --&gt; left
 matrix[lastMinusOffset][first] = matrix[last][lastMinusOffset];

 // move values from right --&gt; bottom
 matrix[last][lastMinusOffset] = matrix[i][last];

 // move values from top --&gt; right
 matrix[i][last] = top;
 }
 }
}
</code></pre>
Here's the code to generate random numbers in a matrix.
<pre class="lang-java prettyprint-override"><code>public static void RotateMatrixImplementation(int len) {
 int[][] matrix = new int[len][];
 var random = new Random();
 for (int i = 0; i &lt; matrix.Length; i++) {
 matrix[i] = new int[len]; // Create inner array
 for (int j = 0; j &lt; matrix[i].Length; j++) {
 //generate random numbers
 matrix[i][j] = random.Next(1, Convert.ToInt32(Math.Pow(len, 3)));
 }
 }
 RotateMatrixBy90Degress(matrix);
}
</code></pre>

blocks|key|2728795|text|这是我对这个问题的100%25结果提交|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2728796|首先，我将2D数组列表分解为1D+arraylist+layerwise，然后旋转1D矩阵，然后再次放置到矩阵形式，同时将2D数组列表分解为1D+arrayList。我已经保存了元素在数组中的位置，以便我们可以将旋转后的矩阵放置在该位置|2728797|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+%25+(A.length);
++++++++int[]+ans+=+new+int[A.length];
++++++++int+y;
++++++++for+(int+i+=+0;+i+<+A.length;+i%2B%2B)+{
++++++++++++y+=+i+-+r;
++++++++++++if+(y+<+0)+{
++++++++++++++++y+%2B=+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+%2B+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);
++++++++++++++++%2B%2Bj;
++++++++++++}
++++++++++++--j;
++++++++++++%2B%2Bi;
++++++++++++while+(i+<+N+-+counter)+{
++++++++++++++++list.add(matrix.get(i).get(j));
++++++++++++++++pos+=+new+Integer[2];
++++++++++++++++pos[0]+=+i;
++++++++++++++++pos[1]+=+j;
++++++++++++++++storePosition.add(pos);
++++++++++++++++%2B%2Bi;
++++++++++++}
++++++++++++--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;
++++++++++++}
++++++++++++%2B%2Bj;
++++++++++++--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);
++++++++++++%2B%2Bcounter;
++++++++++++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%2B%2B)+{

++++++++++++rotatedLinearMat.add(f,+rotateOneDArray(linearMat.get(f),+r));
++++++++}

++++++++int+p+=+0;

++++++++Integer[][]+result+=+new+Integer[n][m];
++++++++for+(int+i+=+0;+i+<+rotatedLinearMat.size();+%2B%2Bi)+{
++++++++++++for+(int+j+=+0;+j+<+rotatedLinearMat.get(i).size();+%2B%2Bj)+{
++++++++++++++++result[storePosition.get(p)[0]][storePosition.get(p)[1]]+=+rotatedLinearMat.get(i).get(j);
++++++++++++++++%2B%2Bp;
++++++++++++}
++++++++}

++++++++for+(int+i+=+0;+i+<+n;+i%2B%2B)+{
++++++++++++for+(int+j+=+0;+j+<+m;+j%2B%2B)+{
++++++++++++++++System.out.print(result[i][j]+%2B+"+");
++++++++++++}
++++++++++++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%2B$",+"").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%2B$",+"").split("+"))
++++++++++++++++++++++++++++++++.map(Integer::parseInt)
++++++++++++++++++++++++++++++++.collect(toList())
++++++++++++++++);
++++++++++++}+catch+(IOException+ex)+{
++++++++++++++++throw+new+RuntimeException(ex);
++++++++++++}
++++++++});

++++++++matrixRotation(matrix,+r);

++++++++bufferedReader.close();
++++}
}|code-block|syntax|javascript|2728798|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's my 100% result submission to this problem
Firstly I've broken the 2D arraylist into 1D arrayList layerwise,
Then rotated 1D matrix
then again placed into matrix form
While breaking 2D arraylist into 1D arrayList I've saved the positions of element in array
so that we can place that rotated matrix at that position
<pre class="lang-java prettyprint-override"><code>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&lt;Integer[]&gt; storePosition = new ArrayList&lt;&gt;();

 public static ArrayList&lt;Integer&gt; rotateOneDArray(List&lt;Integer&gt; arr, int K) {
 int[] A = arr.stream().mapToInt(i -&gt; 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 &lt; A.length; i++) {
 y = i - r;
 if (y &lt; 0) {
 y += A.length;
 }
 ans[y] = A[i];
 }
 return (ArrayList&lt;Integer&gt;) Arrays.stream(ans).boxed().collect(Collectors.toList());
 }

 static ArrayList&lt;ArrayList&lt;Integer&gt;&gt; getLinearMatrix(List&lt;List&lt;Integer&gt;&gt; matrix) {
 ArrayList&lt;ArrayList&lt;Integer&gt;&gt; linear = new ArrayList&lt;ArrayList&lt;Integer&gt;&gt;();
 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 &gt;= 2 &amp;&amp; n &gt;= 2) {
 i = counter;
 j = counter;

 ArrayList&lt;Integer&gt; list = new ArrayList&lt;&gt;((m + n - 2) * 2);

 while (j &lt; 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 &lt; 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 &gt;= 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 &gt; 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&lt;List&lt;Integer&gt;&gt; matrix, int r) {
 int m = matrix.get(0).size();
 int n = matrix.size();

 ArrayList&lt;ArrayList&lt;Integer&gt;&gt; linearMat = getLinearMatrix(matrix);
 ArrayList&lt;ArrayList&lt;Integer&gt;&gt; rotatedLinearMat = new ArrayList&lt;ArrayList&lt;Integer&gt;&gt;();

 for (int f = 0; f &lt; 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 &lt; rotatedLinearMat.size(); ++i) {
 for (int j = 0; j &lt; 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 &lt; n; i++) {
 for (int j = 0; j &lt; m; j++) {
 System.out.print(result[i][j] + &quot; &quot;);
 }
 System.out.println();
 }
 }

 public static void main(String[] args) throws IOException {
 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

 String[] mnr = bufferedReader.readLine().replaceAll(&quot;\\s+$&quot;, &quot;&quot;).split(&quot; &quot;);

 int m = Integer.parseInt(mnr[0]);
 int n = Integer.parseInt(mnr[1]);
 int r = Integer.parseInt(mnr[2]);

 List&lt;List&lt;Integer&gt;&gt; matrix = new ArrayList&lt;&gt;();

 IntStream.range(0, m).forEach(i -&gt; {
 try {
 matrix.add(
 Stream.of(bufferedReader.readLine().replaceAll(&quot;\\s+$&quot;, &quot;&quot;).split(&quot; &quot;))
 .map(Integer::parseInt)
 .collect(toList())
 );
 } catch (IOException ex) {
 throw new RuntimeException(ex);
 }
 });

 matrixRotation(matrix, r);

 bufferedReader.close();
 }
}
</code></pre>

blocks|key|149652|text|在这段代码中，你可以将NxN矩阵旋转一次，你也可以选择方向1表示时钟方向，-1表示相反方向。在rotateMatrix方法中，每个角落都需要for-for循环。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|149653|公共类JavaApplication144+{|149654|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();
}|code-block|syntax|javascript|149655|下面是方法：|149656|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%2B%2B)+{
++++++++++++for+(int+j+=+0;+j+<+p_matris[0].length;+j%2B%2B)+{
++++++++++++++++if+(i+==+0+&&+j+!=+p_matris[0].length+-+1)+{
++++++++++++++++++++tempmatris[i][j+%2B+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%2B%2B)+{
++++++++++++for+(int+j+=+0;+j+<+p_matris[0].length;+j%2B%2B)+{
++++++++++++++++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+%2B+1][j]+=+p_matris[i][j];

++++++++++++++++}
++++++++++++}
++++++++}

++++}+else+if+(dırectıon+==+1)+{
++++++++for+(int+i+=+0;+i+<+p_matris.length;+i%2B%2B)+{
++++++++++++for+(int+j+=+0;+j+<+p_matris[1].length;+j%2B%2B)+{
++++++++++++++++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+%2B+1]+=+p_matris[i][j];
++++++++++++++++}
++++++++++++}
++++++++}
++++++++for+(int+i+=+0;+i+<+p_matris.length;+i%2B%2B)+{
++++++++++++for+(int+j+=+0;+j+<+p_matris[0].length;+j%2B%2B)+{
++++++++++++++++if+(j+==+0+&&+i+!=+p_matris.length+-+1)+{
++++++++++++++++++++tempmatris[i+%2B+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%2B%2B)+{
++++++++for+(int+j+=+1;+j+<+p_matris[1].length+-+1;+j%2B%2B)+{
++++++++++++tempmatris[i][j]+=+p_matris[i][j];
++++++++}
++++}
++++return+tempmatris;
}|149657|}|149658|此外，您还需要打印矩阵。通过该方法可以：|149659|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%2B%2B)+{
++++++++System.out.println("+");
++++++++for+(int+j+=+0;+j+<+matrix.length;+j%2B%2B)+{
++++++++++++System.out.print("+");
++++++++++++System.out.print(matrix[i][j]+%2B+"+");
++++++++}
++++}

++++for+(int+i+=+0;+i+<+dondurme;+i%2B%2B)+{
++++++++matrix+=+shiftingmatris(matrix,+dırectıon);
++++}
++++System.out.println("+");
++++for+(int+i+=+0;+i+<+matrix.length;+i%2B%2B)+{
++++++++System.out.println("+");
++++++++for+(int+j+=+0;+j+<+matrix.length;+j%2B%2B)+{
++++++++++++System.out.print("+");
++++++++++++System.out.print(matrix[i][j]+%2B+"+");
++++++++}
++++}
}|149660|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

In this code, you Will be able to turn NxN matrix for a times also you can choose the direction 1 means Clock-wise, -1 means opposite of it.
In the rotateMatrix method you Will be needed for-for loops each corner.
public class JavaApplication144 {
<pre><code>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();
}
</code></pre>
here is the method:
<pre><code>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 &lt; p_matris.length; i++) {
 for (int j = 0; j &lt; p_matris[0].length; j++) {
 if (i == 0 &amp;&amp; j != p_matris[0].length - 1) {
 tempmatris[i][j + 1] = p_matris[i][j];
 } else if (i == p_matris.length - 1 &amp;&amp; j != 0) {
 tempmatris[i][j - 1] = p_matris[i][j];
 }
 }
 }
 for (int i = 0; i &lt; p_matris.length; i++) {
 for (int j = 0; j &lt; p_matris[0].length; j++) {
 if (j == 0 &amp;&amp; i != 0) {
 tempmatris[i - 1][j] = p_matris[i][j];
 } else if (j == p_matris[1].length - 1 &amp;&amp; i != p_matris.length - 1) {
 tempmatris[i + 1][j] = p_matris[i][j];

 }
 }
 }

 } else if (dırectıon == 1) {
 for (int i = 0; i &lt; p_matris.length; i++) {
 for (int j = 0; j &lt; p_matris[1].length; j++) {
 if (i == 0 &amp;&amp; j != 0) {
 tempmatris[i][j - 1] = p_matris[i][j];

 } else if (i == p_matris.length - 1 &amp;&amp; j != p_matris[0].length - 1) {
 tempmatris[i][j + 1] = p_matris[i][j];
 }
 }
 }
 for (int i = 0; i &lt; p_matris.length; i++) {
 for (int j = 0; j &lt; p_matris[0].length; j++) {
 if (j == 0 &amp;&amp; i != p_matris.length - 1) {
 tempmatris[i + 1][j] = p_matris[i][j];
 } else if (j == p_matris[0].length - 1 &amp;&amp; i != 0) {
 tempmatris[i - 1][j] = p_matris[i][j];

 }
 }
 }

 }

 for (int i = 1; i &lt; p_matris.length - 1; i++) {
 for (int j = 1; j &lt; p_matris[1].length - 1; j++) {
 tempmatris[i][j] = p_matris[i][j];
 }
 }
 return tempmatris;
}
</code></pre>
}
Also you Will be needed to print the matrix. It is possible by that method:
<pre><code>public static void print(){
 Scanner s = new Scanner(System.in);
 System.out.println(&quot;times of rotate: &quot;);
 int dondurme = s.nextInt();
 System.out.println(&quot;direction?&quot;);
 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(&quot; &quot;);
 for (int i = 0; i &lt; matrix.length; i++) {
 System.out.println(&quot; &quot;);
 for (int j = 0; j &lt; matrix.length; j++) {
 System.out.print(&quot; &quot;);
 System.out.print(matrix[i][j] + &quot; &quot;);
 }
 }

 for (int i = 0; i &lt; dondurme; i++) {
 matrix = shiftingmatris(matrix, dırectıon);
 }
 System.out.println(&quot; &quot;);
 for (int i = 0; i &lt; matrix.length; i++) {
 System.out.println(&quot; &quot;);
 for (int j = 0; j &lt; matrix.length; j++) {
 System.out.print(&quot; &quot;);
 System.out.print(matrix[i][j] + &quot; &quot;);
 }
 }
}
</code></pre>

This is a question from Cracking the Coding Interview. The solution says that the program rotates the exterior edges, then the interior edges. However, I'm having trouble following the logic of both the for loops. 

Could somebody explain the logic of the code (e.g. why they do "layer &lt; n/2" and the four steps of "left -> top" and "bottom -> left" etc)? On a side note, how would one's thought process be when coming up with this during a coding interview?

<blockquote>
 Given an image represented by an NxN matrix, where each pixel in the
 image is 4 bytes, write a method to rotate the image by 90 degrees.
 Can you do this in place?
</blockquote>

<pre><code>public static void rotate(int[][] matrix, int n) {
 for (int layer = 0; layer &lt; n / 2; ++layer) {
 int first = layer;
 int last = n - 1 - layer;
 for(int i = first; i &lt; last; ++i) {
 int offset = i - first;
 int top = matrix[first][i]; // save top

 // left -&gt; top
 matrix[first][i] = matrix[last-offset][first]; 

 // bottom -&gt; left
 matrix[last-offset][first] = matrix[last][last - offset]; 

 // right -&gt; bottom
 matrix[last][last - offset] = matrix[i][last]; 

 // top -&gt; right
 matrix[i][last] = top; // right &lt;- saved top
 }
 }
}
</code></pre>

Rotating a NxN matrix in Java

Java

这是破解编码面试中的一个问题。解决方案是，程序先旋转外部边，然后旋转内部边。但是，我在理解这两个for循环的逻辑时遇到了问题。谁能解释一下代码的逻辑(例如，为什么要做"layer < n/2“，以及"left -> top”和"bottom -> left“的四个步骤，等等)？顺便说一句，当一个人在编码面试中想出这个问...

问在Java中旋转NxN矩阵
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中旋转NxN矩阵EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中旋转NxN矩阵
EN