蓝桥杯备考随手记: 常见的二维数组问题

在Java中，二维数组是一种可以存储多个元素的数据结构。它由多个一维数组组成，这些一维数组可以看作是行和列的组合，形成了一个矩阵。

1. 二维数组旋转问题

二维数组的旋转是指将数组中的元素按照一定规则进行旋转。通常有两种常见的旋转方式：顺时针旋转和逆时针旋转。

对于一个二维数组， 旋转操作可以分为以下几个步骤：

1. 先将二维数组转置（即行列互换）
2. 然后将每一行（顺时针）或每一列（逆时针）逆序

下面以顺时针旋转进行演示： 

如果原始数组为：

1 2 3
4 5 6
7 8 9

转置后的数组为：

1 4 7
2 5 8
3 6 9

逆序每一行后的数组为：

7 4 1
8 5 2
9 6 3

这两个操作结合起来就实现了二维数组的旋转操作。

下面使用代码分别实现顺时针与逆时针旋转二维数组的操作：

顺时针旋转

public static void rotate(int[][] matrix) {int n = matrix.length; // 获取二维数组的大小，即行数或列数// Step 1: 转置操作for (int i = 0; i < n; i++) {for (int j = i; j < n; j++) {// 交换matrix[i][j]和matrix[j][i]的值int temp = matrix[i][j];matrix[i][j] = matrix[j][i];matrix[j][i] = temp;}}// Step 2: 行逆序操作for (int i = 0; i < n; i++) {for (int j = 0; j < n / 2; j++) {// 交换matrix[i][j]和matrix[i][n - 1 - j]的值int temp = matrix[i][j];matrix[i][j] = matrix[i][n - 1 - j];matrix[i][n - 1 - j] = temp;}}
}

 逆时针旋转

public static void antiRotate(int[][] matrix) {int n = matrix.length; // 获取二维数组的大小，即行数或列数// Step 1: 转置操作for (int i = 0; i < n; i++) {for (int j = i; j < n; j++) {// 交换matrix[i][j]和matrix[j][i]的值int temp = matrix[i][j];matrix[i][j] = matrix[j][i];matrix[j][i] = temp;}}// Step 2: 列逆序操作for (int i = 0; i < n / 2; i++) {for (int j = 0; j < n; j++) {// 交换matrix[i][j]和matrix[n - 1 - i][j]的值int temp = matrix[i][j];matrix[i][j] = matrix[n - 1 - i][j];matrix[n - 1 - i][j] = temp;}}
}

2. 二维数组找规律问题

二维数组数据的找规律是通过观察数组中的元素，寻找其中的规律或者模式。

以下是一些常见的二维数组数据找规律的方法和技巧：

1. 观察元素的位置关系：通常情况下，二维数组中的元素有着特定的位置关系，如递增或递减的行索引或列索引、对角线上的元素等。通过观察这些位置关系，可以发现其中的规律。

2. 分析元素的数值变化：观察数组中元素的数值变化可以帮助我们找到其中的规律。例如，数组中的元素可能按照一定的规则进行递增或递减，或者存在某种数值变化的模式。

3. 观察特定区域的数值规律：有时候，二维数组中的特定区域可能存在一些数值规律。通过观察这些区域中元素的数值变化，可以发现其中的规律，并将其应用到其他区域。

4. 利用数学公式或算法：对于一些特殊的二维数组，可能存在一些数学公式或算法来描述其中的规律。通过应用这些公式或算法，可以更容易地找到数据的规律。

下面是一些常见的二维数组数据找规律的示例： 

最值相关：

1. 找最大值和最小值：遍历整个二维数组，比较每个元素的大小，找出其中的最大值和最小值。

   // 找到二维数组中的最大值和最小值
   int max = array[0][0]; // 初始化最大值为数组第一个元素
   int min = array[0][0]; // 初始化最小值为数组第一个元素// 遍历整个二维数组，比较每个元素的大小，更新最大值和最小值
   for (int row = 0; row < array.length; row++) {for (int col = 0; col < array[row].length; col++) {if (array[row][col] > max) {max = array[row][col]; // 更新最大值}if (array[row][col] < min) {min = array[row][col]; // 更新最小值}}
   }// 输出最大值和最小值
   System.out.println("最大值：" + max);
   System.out.println("最小值：" + min);
   

2. 判断是否存在特定的元素：遍历整个二维数组，通过比较元素的值，判断是否存在特定的元素。

   // 判断二维数组中是否存在特定的元素
   int targetElement = 5; // 要查找的目标元素
   boolean elementExists = false; // 初始化是否存在目标元素的标志为false// 遍历整个二维数组，通过比较元素的值，判断是否存在目标元素
   for (int row = 0; row < array.length; row++) {for (int col = 0; col < array[row].length; col++) {if (array[row][col] == targetElement) {elementExists = true; // 标记目标元素存在break; // 跳出内层循环}}if (elementExists) {break; // 跳出外层循环}
   }// 输出是否存在目标元素
   System.out.println("是否存在元素 " + targetElement + "：" + elementExists);
   

和相关：

1. 找每行的和：遍历二维数组的每一行，将该行的所有元素相加求和。

   // 找到每行的和
   for (int i = 0; i < array.length; i++) {int sum = 0;for (int j = 0; j < array[i].length; j++) {sum += array[i][j];}System.out.println("第 " + (i + 1) + " 行的和：" + sum);
   }
   

2. 找每列的和：遍历二维数组的每一列，将该列的所有元素相加求和。

   // 找到每列的和
   for (int j = 0; j < array[0].length; j++) {int sum = 0;for (int i = 0; i < array.length; i++) {sum += array[i][j];}System.out.println("第 " + (j + 1) + " 列的和：" + sum);
   }
   

3. 求行或列的和：遍历整个二维数组，将每行或者每列的元素进行累加求和。

   // 求二维数组中指定行和指定列的和
   int rowSum = 0; // 保存指定行的和
   int colSum = 0; // 保存指定列的和
   int targetRow = 2; // 指定行索引
   int targetCol = 1; // 指定列索引// 遍历整个二维数组，累加指定行和指定列的元素
   for (int i = 0; i < array.length; i++) {rowSum += array[targetRow][i];  colSum += array[i][targetCol];  
   }// 输出指定行和指定列的和
   System.out.println("第 " + targetRow + " 行的和：" + rowSum);
   System.out.println("第 " + targetCol + " 列的和：" + colSum);
   

4. 找对角线的和：对角线分为主对角线和副对角线。主对角线从左上角到右下角，副对角线从右上角到左下角。分别求出对角线上的元素和。

   // 找到对角线的和
   int mainSum = 0;
   int antiSum = 0;
   for (int i = 0; i < array.length; i++) {mainSum += array[i][i];antiSum += array[i][array.length - 1 - i];
   }System.out.println("主对角线的和：" + mainSum);
   System.out.println("副对角线的和：" + antiSum);
   

遍历相关：

1. 螺旋顺序遍历：对于一个二维数组，按照顺时针螺旋的顺序遍历元素。我们可以使用四个变量来表示当前螺旋的上界、下界、左界、右界，然后按照顺时针方向不断缩小边界。

   // 按顺时针螺旋顺序遍历二维数组元素
   int top = 0;
   int bottom = array.length - 1;
   int left = 0;
   int right = array[0].length - 1;while (top <= bottom && left <= right) {// 从左到右for (int i = left; i <= right; i++) {System.out.println(array[top][i]);}top++;// 从上到下for (int i = top; i <= bottom; i++) {System.out.println(array[i][right]);}right--;// 从右到左if (top <= bottom) {for (int i = right; i >= left; i--) {System.out.println(array[bottom][i]);}bottom--;}// 从下到上if (left <= right) {for (int i = bottom; i >= top; i--) {System.out.println(array[i][left]);}left++;}
   }
   

2. 遍历特定条件的元素集合：对于一个二维数组，找出特定元素的集合。我们可以使用一个循环遍历数组，然后判断当前元素是否满足特定条件。

   // 找出二维数组中特定元素的集合
   List<Integer> resultList = new ArrayList<>();
   int targetValue = 5; // 要查找的目标值for (int i = 0; i < array.length; i++) {for (int j = 0; j < array[i].length; j++) {if (array[i][j] == targetValue) {resultList.add(array[i][j]); // 将满足条件的元素添加到结果集合中}}
   }System.out.println(resultList);
   

3. 寻找对角线元素：对于一个正方形的二维数组，从左上角到右下角（或者从右上角到左下角）的对角线上的元素具有一些规律。

   // 输出正方形二维数组的对角线元素
   int n = array.length; // 假设是一个 n x n 的二维数组
   // 输出左上角到右下角的对角线
   for (int i = 0; i < n; i++) {System.out.println(array[i][i]);
   }
   // 输出右上角到左下角的对角线
   for (int i = 0; i < n; i++) {System.out.println(array[i][n - 1 - i]);
   }
   

4. 寻找螺旋形元素：可以按照顺时针或者逆时针的方向，以螺旋状从外向内输出二维数组的元素。

   // 按顺时针方向输出二维数组的元素
   int m = array.length; // 行数
   int n = array[0].length; // 列数
   int rowStart = 0;
   int rowEnd = m - 1;
   int colStart = 0;
   int colEnd = n - 1;while (rowStart <= rowEnd && colStart <= colEnd) {// 输出上边界for (int i = colStart; i <= colEnd; i++) {System.out.println(array[rowStart][i]);}rowStart++;// 输出右边界for (int i = rowStart; i <= rowEnd; i++) {System.out.println(array[i][colEnd]);}colEnd--;// 输出下边界if (rowStart <= rowEnd) {for (int i = colEnd; i >= colStart; i--) {System.out.println(array[rowEnd][i]);}rowEnd--;}// 输出左边界if (colStart <= colEnd) {for (int i = rowEnd; i >= rowStart; i--) {System.out.println(array[i][colStart]);}colStart++;}
   }
   

5. 搜索特定元素的位置：可以使用遍历整个二维数组的方法来搜索特定元素的位置。

   // 找到二维数组中特定值的位置（行和列索引）
   int targetValue = 5; // 要查找的目标值
   int targetRowIndex = -1; // 初始化目标值的行索引为-1
   int targetColIndex = -1; // 初始化目标值的列索引为-1// 遍历整个二维数组，找到目标值的位置
   for (int row = 0; row < array.length; row++) {for (int col = 0; col < array[row].length; col++) {if (array[row][col] == targetValue) {targetRowIndex = row; // 更新目标值的行索引targetColIndex = col; // 更新目标值的列索引break; // 找到目标值后跳出内层循环}}if (targetRowIndex != -1 && targetColIndex != -1) {break; // 如果已找到目标值的位置，跳出外层循环}
   }// 输出目标值的位置
   System.out.println("元素 " + targetValue + " 的位置：(" + targetRowIndex + ", " + targetColIndex + ")");
   

差值相关：

1. 找相邻元素的差值：遍历二维数组，找到相邻元素之间的差值。

   // 找到相邻元素的差值
   for (int i = 0; i < array.length; i++) { // 遍历二维数组的行for (int j = 0; j < array[i].length - 1; j++) { // 遍历当前行的元素（除最后一个元素）int diff = array[i][j + 1] - array[i][j]; // 计算相邻两列元素的差值System.out.println("第 " + (i + 1) + " 行第 " + (j + 1) + " 列和第 " + (j + 2) + " 列的差值：" + diff); // 输出差值信息}
   }
   

元素翻转相关：

1. 数组元素翻转：将二维数组的元素按指定规律进行翻转，例如将每一列的元素倒序排列。

   // 对二维数组的每一行进行翻转（倒序排列）
   for (int i = 0; i < arr.length; i++) { // 遍历二维数组的行int start = 0; // 起始位置int end = arr[i].length - 1; // 结束位置while (start < end) { // 反转当前行的元素int temp = arr[i][start]; // 临时变量存储起始位置的值arr[i][start] = arr[i][end]; // 将结束位置的值赋给起始位置arr[i][end] = temp; // 将临时变量的值赋给结束位置start++; // 起始位置右移end--; // 结束位置左移}
   }
   

统计相关：

1. 查找特定值的出现次数：统计二维数组中特定值的出现次数。

   // 统计二维数组中特定值的出现次数
   int target = 5; // 目标值
   int count = 0; // 计数器，用于统计目标值出现的次数
   for (int row = 0; row < arr.length; row++) { // 遍历二维数组的行for (int col = 0; col < arr[row].length; col++) { // 遍历二维数组的列if (arr[row][col] == target) { // 如果当前元素等于目标值count++; // 增加计数}}
   }
   System.out.println("元素 " + target + " 出现的次数：" + count); // 输出目标值出现的次数
   

3. 杨辉三角

杨辉三角，也称为帕斯卡三角形，是一个数学上的图形，它由数字构成的三角形。

杨辉三角的第一行只有一个数字 1，从第二行开始，每个数字都是它上方两个数字的和。具体来说，对于第n行第m个数字，它的值等于第n-1行第m-1个数字加上第n-1行第m个数字。

杨辉三角的特点是每个数字等于它上方两个数字之和，并且每一行的数字依次递增。它的结构非常规则，可以形成一个三角形的形状。

杨辉三角一些基本性质：

1. 第n行有n个元素。
2. 第n行的元素可以通过组合数公式计算得到，第n行的第k个元素（从0开始）等于C(n, k)，其中C(n, k)表示从n个元素中选择k个元素的组合数。
3. 杨辉三角中的每一行都是对称的。

可以利用二维数组的行与列的关系来实现杨辉三角:

public class YanghuiTriangle {public static void main(String[] args) {int numRows = 5; // 杨辉三角的行数int[][] yanghuiTriangle = new int[numRows][]; // 用于存储三角形的二维数组// 填充杨辉三角的值for (int row = 0; row < numRows; row++) {yanghuiTriangle[row] = new int[row + 1];yanghuiTriangle[row][0] = 1; // 每行的第一个元素为1yanghuiTriangle[row][row] = 1; // 每行的最后一个元素为1// 计算每行其余元素的值for (int col = 1; col < row; col++) {// 当前行和列的元素值等于上一行同列元素和上一行同列前一个元素的和yanghuiTriangle[row][col] = yanghuiTriangle[row-1][col-1] + yanghuiTriangle[row-1][col];}}// 输出杨辉三角for (int i = 0; i < yanghuiTriangle.length; i++) {for (int j = 0; j < yanghuiTriangle[i].length; j++) {System.out.print(yanghuiTriangle[i][j] + " ");}System.out.println();}}
}

以上代码输出的结果为：

1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1