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

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

1. 二维数组旋转问题

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

以顺时针旋转为例，下面详细介绍如何将一个二维数组顺时针旋转90度：

假设有一个3x3的二维数组arr如下所示：

1 2 3
4 5 6
7 8 9

旋转后的结果应该是：

7 4 1
8 5 2
9 6 3

可以按照以下步骤进行操作:

1. 创建一个新的二维数组rotatedArr，其行数和列数与原数组arr相同。

2. 使用两个嵌套的for循环遍历原数组arr中的每个元素。假设当前元素的坐标为(i, j)，则旋转后的坐标应该为(j, n-1-i)，其中n为数组的行数。

3. 将原数组arr中的元素arr[i][j]赋值给新数组rotatedArr的对应位置rotatedArr[j][n-1-i]，完成数组的旋转。

4. 最后，遍历新数组rotatedArr，并输出旋转后的结果。

以下是用Java代码实现上述过程的示例：

int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] rotatedArr = new int[arr.length][arr[0].length];

for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        rotatedArr[j][arr.length - 1 - i] = arr[i][j];
    }
}

// 输出旋转后的数组
for (int i = 0; i < rotatedArr.length; i++) {
    for (int j = 0; j < rotatedArr[i].length; j++) {
        System.out.print(rotatedArr[i][j] + " ");
    }
    System.out.println();
}

以上代码输出的结果为：

7 4 1 
8 5 2 
9 6 3 

通过以上步骤，我们可以将一个二维数组顺时针旋转90度。同样的道理，如果需要逆时针旋转90度，只需要将坐标的转换关系修改为(rotatedArr[n-1-j][i])即可。

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; // 每行的第一个元素为1
            yanghuiTriangle[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