將陣列交換到原始狀態

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

結果：GBEHINMTODALSVQPWFYXC JKRUZ

我本來嘗試使用相同的公式反向還原數組，但是即使在沒有索引超出范圍的情況下進行編譯，異常仍不會將數組還原為原始狀態！

 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]+" ");

結果：GNOPWREBCHADITQZKLMVS FYJUX

這是由建議的反向版本

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

結果：IXYBENKTGPSDQZOFAHMVU LCJWR

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循環是完全必要的，並且刪除它們會大大提高該代碼的可讀性，正如您可能已經注意到的那樣，真的真的真的很重要。

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

實際上，這會使您的陣列恢復其原始狀態。 試試看。