Cracking the coding interview--Q1.6

原文：

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?

译文：

一张图像表示成NxN的矩阵，图像中每个像素是4个字节，写一个函数把图像旋转90度。 你能原地进行操作吗？(即不开辟额外的存储空间)

假设矩阵顺时针旋转90度，假设测试数据如下：

1 2 3 4               13  9 5 1
5 6 7 8         ==>   14 10 6 2
9 10 11 12            15 11 7 3
13 14 15 16           16 12 8 4

方法一：

数组下标0开始，旋转规律：（i,j）->(j,n-1-i)->(n-1-i,n-1-j)->(n-i-j,i)->(i,j)

也就是说开始坐标(i,j)转向(j,n-1-i),(j,n-1-i)转向(n-1-i,n-1-j)类推

/**
* 顺时针旋转90度
* 数组下标0开始，旋转规律：（i,j）->(j,n-1-i)->(n-1-i,n-1-j)->(n-i-j,i)->(i,j)
* 也就是说开始坐标(i,j)转向(j,n-1-i),(j,n-1-i)转向(n-1-i,n-1-j)类推
*
* 去除重复选装数字
*/
public static void rotateArray(int array[][], int n) {
int tem;
for(int i=0; i<n/2; i++) {
for(int j=i; j<n-1-i; j++) {
tem = array[i][j];
array[i][j] = array[n-1-j][i];
array[n-1-j][i] = array[n-1-i][n-1-j];
array[n-1-i][n-1-j] = array[j][n-1-i];
array[j][n-1-i] = tem;
}
}
}

方法二：



第一步交换主对角线两侧的对称元素，第二步交换第j列和第n-1-j列

/**
* 规律：第一步交换主对角线两侧的对称元素，第二步交换第j列和第n-1-j列
*/
public static void rotateArray2(int array[][], int n) {
int tem;
// 主对角线两侧的对称元素
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
tem = array[i][j];
array[i][j] = array[j][i];
array[j][i] = tem;
}
}

for(int j=0; j<n/2; j++) {
for(int i=0; i<n; i++) {
tem = array[i][j];
array[i][j] = array[i][n-1-j];
array[i][n-1-j] = tem;
}
}
}

主要代码如下：

package chapter_1_arraysandstring;

import java.util.Scanner;

/**
* 一张图像表示成NxN的矩阵，图像中每个像素是4个字节，写一个函数把图像旋转90度。 你能原地进行操作吗？(即不开辟额外的存储空间)
*
* @author LiangGe
*
*/
public class Question_1_6 {

/**
* 顺时针旋转90度 数组下标0开始，旋转规律：（i,j）->(j,n-1-i)->(n-1-i,n-1-j)->(n-i-j,i)->(i,j)
* 也就是说开始坐标(i,j)转向(j,n-1-i),(j,n-1-i)转向(n-1-i,n-1-j)类推
*
* 去除重复选装数字
*/
public static void rotateArray(int array[][], int n) {
int tem;
for (int i = 0; i < n / 2; i++) {
for (int j = i; j < n - 1 - i; j++) {
tem = array[i][j];
array[i][j] = array[n - 1 - j][i];
array[n - 1 - j][i] = array[n - 1 - i][n - 1 - j];
array[n - 1 - i][n - 1 - j] = array[j][n - 1 - i];
array[j][n - 1 - i] = tem;
}
}
}

/**
* 规律：第一步交换主对角线两侧的对称元素，第二步交换第j列和第n-1-j列
*/
public static void rotateArray2(int array[][], int n) {
int tem;
// 主对角线两侧的对称元素
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
tem = array[i][j];
array[i][j] = array[j][i];
array[j][i] = tem;
}
}

for(int j=0; j<n/2; j++) {
for(int i=0; i<n; i++) {
tem = array[i][j];
array[i][j] = array[i][n-1-j];
array[i][n-1-j] = tem;
}
}
}

/**
* 规律：第一步交换副对角线两侧的对称元素，第二步交换第i行和第n-1-i行
*/
public static void rotateArray3(int array[][], int n) {
int tem;
for(int i=0; i<n-1; i++) {
for(int j=0; j<n-1-i; j++) {
tem = array[i][j];
array[i][j] = array[n-1-j][n-1-i];
array[n-1-j][n-1-i] = tem;
}
}

for(int i=0; i<n/2; i++) {
for(int j=0; j<n; j++) {
tem = array[i][j];
array[i][j] = array[n-1-i][j];
array[n-1-i][j] = tem;
}
}
}

/**
* 打印矩阵
*/
public static void printArray(int array[][], int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.printf("%3d", array[i][j]);
}
System.out.println();
}
}

public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int number = Integer.parseInt(scanner.nextLine());
// number测试组
while (number-- > 0) {
String curStrLine = scanner.nextLine();
String[] curStr = curStrLine.split(" ");
int n = Integer.parseInt(curStr[0]);
int array[][] = new int

;

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
array[i][j] = scanner.nextInt();
}
scanner.nextLine();
}
System.out.println("before rotate ....");
printArray(array, n);
// 顺时针旋转90度
rotateArray3(array, n);

System.out.println("after rotate ....");
printArray(array, n);
}
}
}