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循环是完全必要的，删除它们会大大改善这段代码＆＃39可读性，正如你可能已经注意到的那样，真的非常重要。

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

这实际上会使您的阵列恢复原状。尝试一下。

将数组交换到其原始状态

3 个答案: