将数组交换到其原始状态

Question

我一直在执行数组相关测试，我尝试按照特定模式交换数组，然后我尝试将数组交换回它最初使用模式的方式，但它始终有效。当我进行测试时，我运行遇到了一个棘手的情况，我的反转模式根本没有发挥作用！我决定 post 我的问题在这里，看看是否有人知道我在尝试反转我的数组时遗漏了什么！数组是不可逆的吗？

数组以及交换模式：

String[] strs = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};

        for(int i = 0; i<strs.length-2; i++){
            String temp = strs[i];
            strs[i] = strs[i+2];
            strs[i+2] = temp;

            for(int r = 0; r<strs.length-6; r++){
                String temp2 = strs[r];
                strs[r] = strs[r+6];
                strs[r+6] = temp2;

                for(int s = 0; s<strs.length-4; s++){
                    String temp3 = strs[s];
                    strs[s] = strs[s+4];
                    strs[s+4] = temp3;

                    for(int t = 0; t<strs.length-2; t++){
                        String temp4 = strs[t];
                        strs[t] = strs[t+2];
                        strs[t+2] = temp4;
                    }
                }
            }
        }

结果：G B E H I N M T O D A L S V Q P W F Y X C J K R U Z

我最初尝试使用相同的反向公式还原数组但即使它在没有索引越界异常的情况下进行编译，它仍然不会将数组恢复到其原始状态！

 for(int i = 0; i<strs.length; i++)
        System.out.print(strs[i]+" ");
        System.out.println("");

        for(int i = strs.length-3; i>=0; i--){
            String temp = strs[i];
            strs[i] = strs[i+2];
            strs[i+2] = temp;

            for(int r = strs.length-7; r>=0; r--){
                String temp2 = strs[r];
                strs[r] = strs[r+6];
                strs[r+6] = temp2;

                for(int s = strs.length-5; s>=0; s--){
                    String temp3 = strs[s];
                    strs[s] = strs[s+4];
                    strs[s+4] = temp3;

                    for(int t = strs.length-3; t>=0; t--){
                        String temp4 = strs[t];
                        strs[t] = strs[t+2];
                        strs[t+2] = temp4;
                    }
                }
            }

        }

        for(int i = 0; i<strs.length; i++)
        System.out.print(strs[i]+" ");

结果：G N O P W R E B C H A D I T Q Z K L M V S F Y J U X

这是

建议的反转版本

for(int i = 0; i<strs.length-2; i++){
            String temp = strs[i];
            strs[i] = strs[i+2];
            strs[i+2] = temp;

            for(int r = 0; r<strs.length-6; r++){
                String temp2 = strs[r];
                strs[r] = strs[r+6];
                strs[r+6] = temp2;

                for(int s = 0; s<strs.length-4; s++){
                    String temp3 = strs[s];
                    strs[s] = strs[s+4];
                    strs[s+4] = temp3;

                    for(int t = 0; t<strs.length-2; t++){
                        String temp4 = strs[t];
                        strs[t] = strs[t+2];
                        strs[t+2] = temp4;
                    }
                }
            }
        }

结果：I X Y B E N K T G P S D Q Z O F A H M V U L C J W R

Answer 1

我想避免在这种情况下为您编写解决方案代码，但问题与您的反转代码循环的起始位置有关。仔细检查这些位置，使用调试器（如果您使用的是 IDE，大多数都内置了这些），然后逐行检查代码。

您会发现您没有从正确的位置开始。

此外，最好始终在任何循环或条件语句之后使用大括号。我在您的代码中注意到，您有两种情况可能会给您的 reader 带来很多混乱。另外，它将帮助您重新适应代码。在您的反向代码中：

for(int i = 0; i<strs.length; i++)
    System.out.print(strs[i]+" ");
    System.out.println("");

// Other loops...

for(int i = 0; i<strs.length; i++)
    System.out.print(strs[i]+" ");

变成

for(int i = 0; i<strs.length; i++) {
    System.out.print(strs[i]+" ");
}
System.out.println("");

// Other loops...

for(int i = 0; i<strs.length; i++) {
    System.out.print(strs[i]+" ");
}

Answer 2

之所以没有恢复到原来的状态，是因为你的反转算法嵌套不正确。

假设您有多个嵌套 for 循环，请考虑此伪代码。

for 1 to 1
     System.out.println("Step 1");

         for 1 to 1
               System.out.println("Step 2")

                       for 1 to 1
                              System.out.println("Step 3")

当运行这个时候，它会打印出第1步，然后是第2步，最后是第3步，对吧？

所以当你想要反转你的算法时，你需要按照相反的顺序执行这些步骤。所以需要先进行步骤3，然后是步骤2，最后是步骤1。

这可能就像颠倒嵌套 for 循环的顺序一样简单，但它也不可能 - 我不完全确定，老实说，我真的不想深入研究这个问题，因为当有这么多嵌套的 for 循环时，我的心开始痛了哈哈。但我希望这能让你走上正轨，如果你有任何问题，请告诉我。

附带说明一下，我强烈建议您考虑重写部分代码 - 我不认为嵌套 for 循环是完全必要的，删除它们会大大提高代码的可读性，因为您可能已经注意到，这真的非常非常重要。

Answer 3

为了反转你之前的算法，你还需要将每个循环中的块顺序（先主交换，然后内循环）反转为（先内循环然后交换），就像这样：

      for(int i = strs.length-3; i>=0; i--)  {         

        for(int r = strs.length-7; r>=0; r--) {                

            for(int s = strs.length-5; s>=0; s--) {                   

                for(int t = strs.length-1; t>=3; t--) {                        
                    String temp4 = strs[t];
                    strs[t] = strs[t-3];
                    strs[t-3] = temp4;
                 }   

                String temp3 = strs[s];
                strs[s] = strs[s+4];
                strs[s+4] = temp3;                    
             }

            String temp2 = strs[r];
            strs[r] = strs[r+6];
            strs[r+6] = temp2; 
         }

        String temp = strs[i];
        strs[i] = strs[i+2];
        strs[i+2] = temp;
     }

这实际上会使您的数组恢复到原来的状态。试试吧。

将数组交换到其原始状态

Swapping an array to its original state

java

arrays

swap