일반 사이클 재귀에서 자바 전체 배열

　　먼저, 주어진 단계 교환 처리는, 예를 들어, 제 생각 ABC를 얻기 위하여 전체 어레이 세 문자 인 ABC, ACB는 ABC 다시 전환 두 글자를주고 다시 전환하고 전방 B, C 및 마지막 정면 출력 뒤에 편지를 교환 한 다음, 다음 ABC로 다시 교환합니다. 다음과 같이 코드입니다 :

공용  클래스 TestDemo3 {
     공공  정적  무효 트랜스 (문자열 STR)은 {
         숯불 [] = 도착 str.toCharArray ()를; 
        교환하다 (도착, 3 ); 
    } 
    
    공공  정적  무효 변경하다은 ( 는 char [] 도착 INT {a)
　　　　  // 在首字母 
        스왑 (도착, arr.length-3 arr.length-3 );
        위한 ( int로 I = 0; I <arr.length; I ++ ) { 
            System.out.print (도착 [I]); 
        } 
        System.out.print ( "" );
        스왑 (도착, arr.length -2 arr.length-1 );
        위한 ( int로 I = 0; I <arr.length; I ++ ) { 
            System.out.print (도착 [I]); 
        } 
        스왑 (도착, arr.length -2, arr.length-1 ); 
        스왑 (도착, arr.length -3,4- arr.length-3 ); 
        에서 System.out.println (); 
        // B在首字母 
        스왑 (도착, arr.length-3 arr.length-2 );
        위한 ( int로 I = 0; I <arr.length; I ++ ) { 
            System.out.print (도착 [I]); 
        } 
        System.out.print ( "" );
        스왑 (도착, arr.length -2 arr.length-1);
        위한 ( int로 I = 0; I <arr.length; I ++ ) { 
            System.out.print (도착 [I]); 
        } 
        스왑 (도착, arr.length -2, arr.length-1 ); 
        스왑 (도착, arr.length -3,4- arr.length-2 ); 
        에서 System.out.println (); 
        // C在首字母 
        스왑 (도착, arr.length-3 arr.length-1 );
        위한 ( int로 I = 0; I <arr.length; I ++ ) { 
            System.out.print (도착 [I]); 
        } 
        System.out.print ( "" ); 
        스왑 (도착, arr.length -2 arr.length-1 );
        위한 ( int로 I = 0; I <arr.length; I ++ ) { 
            System.out.print (도착 [I]); 
        } 
        스왑 (도착, arr.length -2, arr.length-1 ); 
        스왑 (도착, arr.length -3,4- arr.length-1 ); 
        
    공공  정적  무효 스왑 ( CHAR는 [] 도착, int로 A, INT의 {B)을
         숯 온도를; 
        임시 =의 도착 [A]; 
        도착 [A] =의 도착 [B] 
        도착 [B] = 온도를; 
    } 
    
    공개  정적  무효 메인 (문자열 []에 args) { 
        트랜스 ( "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)
.
.
.