通常のサイクル再帰からJavaの完全な配列

　　まず、所定のステップ交換プロセスは、例えば、最初のアイデアは、ABCを得るために、完全な配列の三個の文字であるABC、ACBはABCバックスイッチング二文字を与えるために再び切り替え、その後フロントB、C、最後にフロント、出力の後ろの手紙のやり取りが続き、その後、戻ってABCに交換します。コードは以下の通りであります：

パブリック クラスTestDemo3 {
     公共 静的 ボイドトランス（文字列str）{
         文字 [] ARR = str.toCharArray（）。
        並び替える（ARR、 3 ）。
    } 
    
    パブリック 静的 ボイド並び替える（CHAR [] ARR、INT A）{
　　　　  // 在首字母 
        スワップ（ARR、arr.length-3、arr.length-3 ）。
        以下のために（int型 i = 0; I <arr.length; I ++ ）{ 
            System.out.print（ARR [I]）。
        } 
        System.out.print（ "" ）。
        スワップ（ARR、arr.length-2、arr.length-1 ）。
        以下のために（int型 i = 0; I <arr.length; I ++ ）{ 
            System.out.print（ARR [I]）。
        } 
        （arr.length ARR、スワップ -2、arr.length-1 ）。
        スワップ（ARR、arr.length arr.length-3、-3 ）。
        System.out.println（）; 
        // B在首字母 
        スワップ（ARR、arr.length-3、arr.length-2 ）。
        以下のために（int型 i = 0; I <arr.length; I ++ ）{ 
            System.out.print（ARR [I]）。
        } 
        System.out.print（ "" -2、arr.length-1）。
        スワップ（ARR、arr.length ）。
        以下のために（int型 i = 0; I <arr.length; I ++ ）{ 
            System.out.print（ARR [I]）。
        } 
        （arr.length ARR、スワップ -2、arr.length-1 ）。
        スワップ（ARR、arr.length arr.length-2、-3 ）。
        System.out.println（）; 
        // C在首字母 
        スワップ（ARR、arr.length-3、arr.length-1 ）。
        以下のために（int型 i = 0; I <arr.length; I ++ ）{ 
            System.out.print（ARR [I]）。
        } 
        System.out.print（ "" ）。
        スワップ（ARR、arr.length-2、arr.length-1 ）。
        以下のために（int型 i = 0; I <arr.length; I ++ ）{ 
            System.out.print（ARR [I]）。
        } 
        （arr.length ARR、スワップ -2、arr.length-1 ）。
        スワップ（ARR、arr.length arr.length-1、-3 ）。
        
    パブリック 静的 ボイドスワップ（CHAR [] ARR、INT、int型B）{
         チャーTEMP。
        一時 =のARR [A]。
        ARR [A] =のARR [B]。
        ARR [B] = TEMP。
    } 
    
    公共の 静的な 無効メイン（文字列[]引数）{ 
        トランス（ "ABCD" ）。
    } 
}

　　次に、以下のように繰り返しコードが再構成され、サイクルが、あるいは部分を繰り返すことができます。

public class TestDemo3 {
    public static void trans( String str ) {
        char[] arr = str.toCharArray();
        permute(arr,0);
    }
    
    public static void permute( char[] arr, int a ) {
        for(int j=a;j<arr.length;j++) {
            swap(arr,a,j);
            for(int k=0;k<arr.length;k++) {
                System.out.print(arr[k]);
            }
            System.out.print(" ");
            swap(arr,arr.length-2,arr.length-1);
            for(int k=0;k<arr.length;k++) {
                System.out.print(arr[k]);
            }
            System.out.println();
            swap(arr,arr.length-2,arr.length-1);
            swap(arr,a,j);
        }
    }
    
    public static void swap( char[] arr, int a, int b ) {
        char temp;
        temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    
    public static void main( String[] args ) {
        trans("abc");
    }
}

　　对于4个字符的字符串，显然以上方法不行，利用循环嵌套可以解决，思路就是，先a在前，按照交换3个字符的字符串的方式交换bcd，再将a与bcd依次交换进行排列。代码如下：

public class TestDemo3 {
    public static void trans( String str ) {
        char[] arr = str.toCharArray();
        permute(arr,0);
    }
    
    public static void permute( char[] arr, int a ) {
        for(int i=a;i<arr.length;i++) {
            swap(arr,a,i);
            for(int j=a+1;j<arr.length;j++) {
                swap(arr,a+1,j);
                for(int k=0;k<arr.length;k++) {
                    System.out.print(arr[k]);
                }
                System.out.print(" ");
                swap(arr,arr.length-2,arr.length-1);
                for(int k=0;k<arr.length;k++) {
                    System.out.print(arr[k]);
                }
                System.out.println();
                swap(arr,arr.length-2,arr.length-1);
                swap(arr,a+1,j);
            }
            swap(arr,a,i);
        }
    }
    
    public static void swap( char[] arr, int a, int b ) {
        char temp;
        temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    
    public static void main( String[] args ) {
        trans("abcd");
    }
}

　　从3个字符的字符串全排列到4个字符的字符串全排列，可以明显的看出来字符串的全排列是一个递归问题，n个字符的字符串全排列相当于有1*2*3*4*5...*n种输出结果，那么可以通过递归来解决n个字符的字符串全排列。首先，由三个字符到四个的全排列，可以发现是在三个字符的基础上外嵌一个for循环，循环4次，并且，每次将首个字母依次替换。利用递归实现嵌套的循环，输出当a=arr.length-1时的数组。

代码如下：

public class TestDemo3 {
    public static int count;
    public static void trans( String str ) {
        char[] arr = str.toCharArray();
        permute(arr,0);
    }
    
    public static void permute( char[] arr, int a ) {
        if(a==arr.length-1) {
            for(int k=0;k<arr.length;k++) {
                System.out.print(arr[k]);
            }
            count++;
            System.out.print(" ");
        }
        if(a==1) {
            System.out.println();
        }
        
        
        for(int i=a;i<arr.length;i++) {
            swap(arr,a,i);
            permute(arr,a+1);
            swap(arr,a,i);
        }
    }
    
    public static void swap( char[] arr, int a, int b ) {
        char temp;
        temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    
    public static void main( String[] args ) {
        trans("abcdf");
        System.out.println();
        System.out.println(count);
    }
}

　　这是一个5字符的字符串全排列，从三个和四个字符的字符串全排列变化中我们可以发现如何去将循环转换为递归。其中递归执行过程大致如下(三个字符)：

i=0
swap (arr,0,0)
permute(arr,1)
    i=1
    swap (arr,1,1)
    permute(arr,2)
        i=2 
        swap (arr,2,2)
        swap (arr,2,2)
    swap (arr,1,1)
    i=2
    swap (arr,1,2)
    permute(arr,2)
        i=2
        swap (arr,2,2)
        swap (arr,2,2)
    swap (arr,1,2)
swap (arr,0,0)
i=1
swap (arr,0,1)
permute(arr,1)
    i=1
    swap (arr,1,1)
    permute(arr,2)
        i=2
        swap (arr,2,2)
        swap (arr,2,2)
        swap (arr,1,1)
    i=2
    swap 1 2
    permute(arr,2)
        i=2
        swap (arr,2,2)
        swap (arr,2,2)
    swap (arr,1,2)
swap (arr,0,1)
.
.
.