如何在Java中翻转2D数组

嗨，我正在做一个简单的L-游戏。我想水平地从左向右翻转数组。比如说,

{ 'x',' ',' ',' ' },

{ 'x',' ',' ',' ' },

{ 'x','x',' ',' ' },

{ ' ',' ',' ',' ' }

我想把它翻到

{ ' ','x',' ',' ' },

{ ' ','x',' ',' ' },

{ 'x','x',' ',' ' },

{ ' ',' ',' ',' ' }

这是我目前的代码

    public void flipArray() {
    int rows = cells.length;
    int cols = cells[0].length;
    char temp[][] = new char[rows][cols];
    for (int i = rows-1; i>=0; i--) {
        for (int j = cols-1; j>=0; j--) {
            temp[rows-1-i][cols-1-j] = cells[i][j];
        }
    }
    for (int i=0; i<rows; i++) {
        for (int j=0; j<cols; j++) {
            System.out.print(temp[i][j] + " ");
        }
    }
    }

---

你的代码太复杂了，我都不想弄明白。如果你把问题分解成子问题，问题就会变得简单和容易掌握

首先是基本构造块，反转单个阵列：

当你把它分解成更小的问题时，你会发现它非常简单

编辑： 在二维数组中查找“L”的边界框可以再次分解为更小的问题。您只需遍历这些行，检查它们是否完全为空，如果不为空，则查找“设置”单元格的最小和最大索引。为简单起见，我使用一种方法在两个嵌套循环中执行此操作：

 static int[] getBoundingBox(char[][] rows) {
     int minY = Integer.MAX_VALUE;
     int maxY = Integer.MIN_VALUE;
     int minX = Integer.MAX_VALUE;
     int maxX = Integer.MIN_VALUE;
     for (int y=0; y<rows.length; ++y) {
         // find the rows min/max populated index
         char[] row = rows[y];
         int rowMinX = Integer.MAX_VALUE;
         int rowMaxX = Integer.MIN_VALUE;
         for (int x=0; x<row.length; ++x) {
             if (row[x] == 'x') {
                 rowMinX = Math.min(rowMinX, x);
                 rowMaxX = Math.max(rowMaxX, x);
             }                 
         }
         // check if the row is empty (min > max)
         if (rowMinX > rowMaxX) {
              // empty row, skip
              continue;
         }
         // update bounding box variables
         minY = Math.min(minY, y);
         maxY = Math.max(maxY, y);
         minX = Math.min(minX, rowMinX);
         maxX = Math.max(maxX, rowMaxX);
     }          
     // result is an array containing the bounds
     return new int[] { minX, minY, maxX, maxY };
}

static int[]getBoundingBox（char[][]行）{
int minY=Integer.MAX_值；
int maxY=整数.MIN_值；
int minX=Integer.MAX_值；
int maxX=整数.MIN_值；
对于（int y=0；y rowMaxX）{
//空行，跳过
继续；
}
//更新边界框变量
minY=Math.min（minY，y）；
maxY=Math.max（maxY，y）；
minX=Math.min（minX，rowMinX）；
maxX=Math.max（maxX，rowMaxX）；
}          
//结果是一个包含边界的数组
返回新的int[]{minX，minY，maxX，maxY}；
}

你现在应该真的能够把这些部分连接起来了

Edit2：剩下要做的就是修改翻转（行[][]）以获取边界，并为minY和maxY之间的行调用翻转（行[]）。然后，行翻转需要从边界传递最小/最大X，并使用传递的值，而不是左/右的0/length。仔细想想，如果你想一想就会明白

---

离题，但可能您仍在学习这一点：您将代码拆分为只解决一个子问题的小方法的原因是，您可以a）从不同的位置重复使用它们来解决相同的问题，b）方法中的代码越少，验证它的功能和是否有效就越容易。将所有内容打包在一个大的方法中会使您更难理解，当您需要在其他地方解决部分问题时，您会重复代码（和工作）。

它真的发生了翻转吗？绘制一个当前输出的图表，以便我们可以与您所需的输出进行比较对不起，它似乎没有发生翻转。我不知道如何实现正确的翻转。@Batty。。如果我没有错的话，因为这是一个L型游戏，输入是一个3x2 L形的图形，输出是一个翻转的“L”（镜像）。@作者我说的对吗？你展示的案例不会翻转你的数组，它会改变元素的位置。如果是翻转（2d翻转），则前3个

x

将位于阵列的最后一个位置。所以最好的解释是谢谢你的回答。但这难道不是将所有行的数组位置从0反转到3吗？我想确定L形曲线的位置（其中一行有2x的（x，x）。然后在同一位置从左向右翻转L。@user2741226这与我理解您的问题的方式有点不同，在这种情况下，您首先需要检测“L”的边界框。这将在两个过程中完成，首先找到min（x，y）和“设置”的任何单元格的最大（x，y）坐标。然后在该矩形内翻转。通过向方法传递附加参数，您可以轻松调整我显示的代码以限制翻转的行和列。我添加了一些更理想的结果来演示我想要的。非常感谢您的帮助。但我不知道如何实现您建议的方法。因为不是OP问题的答案。请编辑您的答案以包含评论（这确实很有帮助，但在我投了否决票后才发布）。@MichałRybak OP用文字问了一件事（我回答了），另一件事是“样本”他展示的数组。所以我回答了他要求的明确性。我忽略了隐含的部分，我同意你出于这个原因否决，尽管我个人从未将提问者问题的模糊性归因于回答者的回答。

 static void flip(char[] array) {
     int left = 0;
     int right = array.length - 1;
     while (left < right) {
         char temp = array[left];
         array[left] = array[right];
         array[right] = temp;
         ++left;
         --right;
     }
 }

static void flip(char[][] rows) {
    for (char[] row : rows) {
        flip(row);
    } 
}

 static int[] getBoundingBox(char[][] rows) {
     int minY = Integer.MAX_VALUE;
     int maxY = Integer.MIN_VALUE;
     int minX = Integer.MAX_VALUE;
     int maxX = Integer.MIN_VALUE;
     for (int y=0; y<rows.length; ++y) {
         // find the rows min/max populated index
         char[] row = rows[y];
         int rowMinX = Integer.MAX_VALUE;
         int rowMaxX = Integer.MIN_VALUE;
         for (int x=0; x<row.length; ++x) {
             if (row[x] == 'x') {
                 rowMinX = Math.min(rowMinX, x);
                 rowMaxX = Math.max(rowMaxX, x);
             }                 
         }
         // check if the row is empty (min > max)
         if (rowMinX > rowMaxX) {
              // empty row, skip
              continue;
         }
         // update bounding box variables
         minY = Math.min(minY, y);
         maxY = Math.max(maxY, y);
         minX = Math.min(minX, rowMinX);
         maxX = Math.max(maxX, rowMaxX);
     }          
     // result is an array containing the bounds
     return new int[] { minX, minY, maxX, maxY };
}