48. 旋转图像
- 原题链接：
- 完成情况：
- 开始分析：
- （1）
- （2）
- （3）
- 解释：
- 如果是一维数组
- 如果是二维数组
- 数组传递的底层原理
原题链接：
48. 旋转图像
https://leetcode.cn/problems/rotate-image/
完成情况：
package 西湖算法题解___中等题;
public class __48旋转图像 {
/**
*
* @param args
*/
public static void main(String[] args) {
int [][] matrix ={{1,2,3},{4,5,6},{7,8,9}};
rotate(matrix);
for (int i = 0; i < matrix.length; ++i) {
for (int j = 0; j < matrix.length; ++j) {
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}
/**
* @param matrix
* @return
*/
public static void rotate(int[][] matrix){
int helper[][] = new int[matrix.length][matrix.length];
//int helper[][] = matrix;
for (int i=0;i< matrix.length;i++){ //针对matrix来说，i是列
int temp=0;
for (int j= matrix.length-1;j>=0; j--){ //则对应j是行
//System.out.println("当前的matirx是:"+matrix[j][i]+"\t当前取得j和i分别为："+j+" "+i);
helper[i][temp] = matrix[j][i];
temp++;
}
//System.out.println();
}
for (int i = 0; i < matrix.length; ++i) {
for (int j = 0; j < matrix.length; ++j) {
matrix[i][j] = helper[i][j];
}
}
//matrix = helper;
}//public void rotate(int[][] matrix)
}
开始分析：
（1）
package 西湖算法题解___中等题;
public class __48旋转图像 {
/**
*
* @param args
*/
public static void main(String[] args) {
int [][] matrix ={{1,2,3},{4,5,6},{7,8,9}};
rotate(matrix);
for (int i = 0; i < matrix.length; ++i) {
for (int j = 0; j < matrix.length; ++j) {
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}
/**
* @param matrix
* @return
*/
public static void rotate(int[][] matrix){
int helper[][] = new int[matrix.length][matrix.length];
//int helper[][] = matrix;
for (int i=0;i< matrix.length;i++){ //针对matrix来说，i是列
int temp=0;
for (int j= matrix.length-1;j>=0; j--){ //则对应j是行
//System.out.println("当前的matirx是:"+matrix[j][i]+"\t当前取得j和i分别为："+j+" "+i);
helper[i][temp] = matrix[j][i];
temp++;
}
//System.out.println();
}
// for (int i = 0; i < matrix.length; ++i) {
// for (int j = 0; j < matrix.length; ++j) {
// matrix[i][j] = helper[i][j];
// }
// }
matrix = helper;
}//public void rotate(int[][] matrix)
}
（2）
做个Test看看：
（3）
package 西湖算法题解___中等题;
public class __48旋转图像 {
/**
*
* @param args
*/
public static void main(String[] args) {
int [][] matrix ={{1,2,3},{4,5,6},{7,8,9}};
rotate(matrix);
for (int i = 0; i < matrix.length; ++i) {
for (int j = 0; j < matrix.length; ++j) {
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}
/**
* @param matrix
* @return
*/
public static void rotate(int[][] matrix){
int helper[][] = new int[matrix.length][matrix.length];
//int helper[][] = matrix;
for (int i=0;i< matrix.length;i++){ //针对matrix来说，i是列
int temp=0;
for (int j= matrix.length-1;j>=0; j--){ //则对应j是行
//System.out.println("当前的matirx是:"+matrix[j][i]+"\t当前取得j和i分别为："+j+" "+i);
helper[i][temp] = matrix[j][i];
temp++;
}
//System.out.println();
}
// for (int i = 0; i < matrix.length; ++i) {
// for (int j = 0; j < matrix.length; ++j) {
// System.out.print(helper[i][j]+" ");
// }
// System.out.println();
// }
// for (int i = 0; i < matrix.length; ++i) {
// for (int j = 0; j < matrix.length; ++j) {
// matrix[i][j] = helper[i][j];
// }
// }
matrix = helper;
for (int i = 0; i < matrix.length; ++i) {
for (int j = 0; j < matrix.length; ++j) {
System.out.print(helper[i][j]+" ");
}
System.out.println();
}
System.out.println("--------------------------------------------------");
for (int i = 0; i < matrix.length; ++i) {
for (int j = 0; j < matrix.length; ++j) {
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}//public void rotate(int[][] matrix)
}
解释：
如果是一维数组
在Java中，一维数组采用=进行赋值操作时，将会发生以下情况：
- 数组引用的传递：如果将一个已存在的数组赋值给另一个数组变量，那么实际上是将数组的引用（内存地址）传递给了新的数组变量。这意味着两个数组变量将引用同一个数组对象。对其中一个数组的修改会影响另一个数组。
int[] array1 = {1, 2, 3};
int[] array2 = array1; // 数组引用的传递，array2引用了同一个数组对象
array2[0] = 100;
System.out.println(array1[0]); // 输出: 100
在上述示例中，array2通过赋值操作引用了array1指向的数组对象。修改array2[0]的值也会影响到array1[0]，因为它们指向同一个数组对象。
- 数组的复制：如果将一个数组复制给另一个数组，那么会创建一个新的数组对象，并将原数组的值复制到新数组中。这样，两个数组变量引用的是两个独立的数组对象，修改其中一个数组不会影响另一个数组。
int[] array1 = {1, 2, 3};
int[] array2 = new int[array1.length];
System.arraycopy(array1, 0, array2, 0, array1.length); // 数组的复制
array2[0] = 100;
System.out.println(array1[0]); // 输出: 1
在上述示例中，使用System.arraycopy方法将array1的值复制到了新的数组array2中。修改array2[0]的值不会影响到array1[0]，因为它们引用的是两个不同的数组对象。
总结：一维数组的赋值操作涉及到数组引用的传递或数组的复制，具体取决于赋值语句的上下文和操作的方式。
如果是二维数组
在Java中，二维数组采用=进行赋值操作时，会发生以下情况：
- 数组引用的传递：如果将一个已存在的二维数组赋值给另一个二维数组变量，实际上是将二维数组的引用（内存地址）传递给了新的数组变量。这意味着两个数组变量将引用同一个二维数组对象。对其中一个数组的修改会影响另一个数组。
int[][] array1 = {{1, 2}, {3, 4}};
int[][] array2 = array1; // 数组引用的传递，array2引用了同一个二维数组对象
array2[0][0] = 100;
System.out.println(array1[0][0]); // 输出: 100
在上述示例中，array2通过赋值操作引用了array1指向的二维数组对象。修改array2[0][0]的值也会影响到array1[0][0]，因为它们引用同一个二维数组对象。
- 数组的复制：如果将一个二维数组复制给另一个二维数组，会创建一个新的二维数组对象，并将原数组的值复制到新数组中。这样，两个数组变量引用的是两个独立的二维数组对象，修改其中一个数组不会影响另一个数组。
int[][] array1 = {{1, 2}, {3, 4}};
int[][] array2 = new int[array1.length][array1[0].length];
for (int i = 0; i < array1.length; i++) {
System.arraycopy(array1[i], 0, array2[i], 0, array1[i].length);
} // 数组的复制
array2[0][0] = 100;
System.out.println(array1[0][0]); // 输出: 1
在上述示例中，通过循环和System.arraycopy方法将array1的值复制到了新的二维数组array2中。修改array2[0][0]的值不会影响到array1[0][0]，因为它们引用的是两个不同的二维数组对象。
总结：二维数组的赋值操作涉及到数组引用的传递或数组的复制，具体取决于赋值语句的上下文和操作的方式。
数组传递的底层原理
在Java中，数组是按值传递的，而不是按引用传递。当将数组作为参数传递给函数时，函数接收到的是原始数组的一个副本，而不是对原始数组的引用。因此，对函数内部对数组进行的修改操作不会影响原始数组。
当你传递数组给函数时，实际上是将数组的副本传递给了函数。这意味着函数内部对数组进行的修改只会影响到副本，而不会影响原始数组。
public static void modifyArray(int[] arr) {
arr[0] = 100; // 修改数组的第一个元素
}
public static void main(String[] args) {
int[] array = {1, 2, 3};
modifyArray(array);
System.out.println(array[0]); // 输出: 1，原始数组没有被修改
}
在上述示例中，modifyArray函数接收一个整型数组作为参数，并将数组的第一个元素修改为100。然而，在主函数中调用modifyArray后，输出的结果仍然是1，原始数组并没有被修改。这是因为传递给modifyArray的是数组的副本，函数内部的修改只影响到副本，不会影响到原始数组。
如果你希望函数能够修改原始数组，可以通过返回值或者使用其他方法来实现。例如，可以让函数返回修改后的数组，并在主函数中将原始数组替换为返回的数组。
public static int[] modifyArray(int[] arr) {
arr[0] = 100; // 修改数组的第一个元素
return arr;
}
public static void main(String[] args) {
int[] array = {1, 2, 3};
array = modifyArray(array);
System.out.println(array[0]); // 输出: 100，原始数组被修改
}
在这个示例中，modifyArray函数同样修改了数组的第一个元素，但是它将修改后的数组作为返回值返回，并在主函数中将原始数组替换为返回的数组。这样，主函数中的array引用就指向了修改后的数组，原始数组被成功地修改了。
总结：数组在函数调用后不会记录到修改数组的操作，是因为数组在函数调用时按值传递，函数接收到的是原始数组的副本。如果你想在函数中修改原始数组，可以通过返回值或者其他方式来实现。
