将数组交换为其原始状态

Question

我一直在执行与数组相关的测试，我尝试按照特定模式交换数组，然后尝试将数组交换回它最初使用模式的方式，相反它总是有效的。当我进行测试时，我遇到了一个棘手的情况，我的反转模式根本无法完成工作！我决定在这里发布我的问题，看看是否有人对我尝试反转数组时缺少的内容有任何见解！数组不可逆吗？

数组连同交换模式：

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

它没有恢复到原始状态的原因是因为你的反转算法嵌套不正确。

考虑一下这个伪代码，假设您有多个嵌套的 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 2

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

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

此外，最佳做法是始终在任何循环或条件之后使用大括号。我在您的代码中注意到您有两种情况，这可能会给您的读者带来很多困惑。此外，它将帮助您重新适应未来的代码。在您的反向代码中：

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 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;
     } 

这实际上会将您的数组恢复到其原始状态。试试看。