全排列（交换，递归，有详细解释）

 

这段话是网上抄来：
1、首先看最后两个数4, 5。 它们的全排列为4 5和5 4, 即以4开头的5的全排列和以5开头的4的全排列。
由于一个数的全排列就是其本身，从而得到以上结果。
2、再看后三个数3, 4, 5。它们的全排列为3 4 5、3 5 4、 4 3 5、 4 5 3、 5 3 4、 5 4 3 六组数。
即以3开头的和4,5的全排列的组合、以4开头的和3,5的全排列的组合和以5开头的和3,4的全排列的组合.
从而可以推断，设一组数p = {r1, r2, r3, ... ,rn}, 全排列为perm(p)，pn = p - {rn}。
因此perm(p) = r1perm(p1), r2perm(p2), r3perm(p3), ... , rnperm(pn)。当n = 1时perm(p} = r1。
为了更容易理解，将整组数中的所有的数分别与第一个数交换，这样就总是在处理后n-1个数的全排列

举2个例子来说明


123的全排列
--首先遍历元素,然后把遍历到的每一个元素都和第一个元素交换
第一个和第一个交换 就是1和1交换 最后还是123
那么就形成了 123  213  321 这样的3组
(交换后 再换回来 还原成123 因为后面的交换都是在123的基础上交换的 所以swap要写2次)

--检查每一组除了第一个之外的剩余元素， 如果这些元素个数是2，
那么就对这剩下的2个元素全排列 就是123 132 ,  213 231 , 321 312
2个元素的全排列很简单 就是把这2个元素交换位置就OK）

1234的全排列
--首先遍历元素,然后把遍历到的每一个元素都和第一个元素交换
那么就形成了 1234  2134  3214 4231 这样的4组

--检查每一组除了第一个之外的剩余元素， 如1234剩余的是234，发现是3个元素
那么问题就转换为求234的全排列了
接下来也是一样 问题转换为求134， 214， 231的全排列

像这样 总是对除了第一个之外的元素全排列， 每次元素的个数都在减少一个，
求N个元素全排列最终就变成求2的元素的全排列了



这里是思维过程 最后才是成品=====================================

package arrange;

public class MyArrange2 {
    char arr[];

    public MyArrange2(char[] arr) {
        this.arr = arr;
    }

    void function(char[] arr) {
        if(arr.length==2){
            System.out.println(arr[0]+""+arr[1]);
            System.out.println(arr[1]+""+arr[0]);
        }else{          
            for (int i = 0; i < arr.length; i++) {
                swap(0, i);
                function(getRemain(arr)); //getRemain的作用是取出除了第一个之外的剩余元素
                swap(0, i);
            }
        }
    }

    char[] getRemain(char[] arr) {
        char[] c = new char[arr.length - 1];
        for (int i = 0; i < c.length; i++) {
            c[i] = arr[i + 1];
        }
        return c;
    }

    private void swap(int i, int j) {
        char c;
        c = arr[i];
        arr[i] = arr[j];
        arr[j] = c;
    }


    public static void main(String[] args) {
        char[] arr = new char[] { '1', '2', '3' };
        MyArrange2 a = new MyArrange2(arr);
        a.function(arr);
    }
}

这样的程序运行起来后，发现一个问题
那就是输出的总是把问题最小化的结果， 前面已经确定下来的排列都弄丢了

因此下面就有改进的方案
上面是每次递归时 都是新的数组，  每次数组中的元素都在减少
下面是每次递归时 仍是原来的数组，只是每次只处理部分元素，所要处理的元素个数越来越少


==========================================

package arrange;

public class MyArrange3 {
    char arr[];

    public MyArrange3(char[] arr) {
        this.arr = arr;
    }

    void function(char[] arr,int k) {
        if(k==(arr.length-2)){
            printHead(arr);
            System.out.println(arr[arr.length-2]+""+arr[arr.length-1]);
            printHead(arr);
            System.out.println(arr[arr.length-1]+""+arr[arr.length-2]);
        }else{          
            for (int i = k; i < arr.length; i++) {
                swap(k, i); //这里就不能写0了， 因为本次的第一个元素要从自己需要处理的元素开始算
                function(arr,k+1);
                swap(k, i);
            }
        }
    }


    private void swap(int i, int j) {
        char c;
        c = arr[i];
        arr[i] = arr[j];
        arr[j] = c;
    }
  
    void printHead(char[] arr){
        for (int i = 0; i < arr.length-2; i++) {
            System.out.print(arr[i]);
        }
    }


    public static void main(String[] args) {
        char[] arr = new char[] { '1', '2', '3' };
        MyArrange3 a = new MyArrange3(arr);
        a.function(arr,0);
    }
}

//=========================================================================
C语言版

#include "stdio.h "
void perm(char arr[],int k,int len);
void swap(char *p,char *q);

char arr[]="1234";
void main(){
    perm(arr,0,4);

}

void perm(char arr[], int k,int len){
    if (k==len-2)
    {
        for (int j=0;j<len;j++)
        {
            printf("%c",arr[j] );  
        }
        printf("\n" );
        for (j=0;j<len-2;j++)
        {
            printf("%c",arr[j] );  
        }
        printf("%c",arr[len-1] );
        printf("%c",arr[len-2] );
        printf("\n" );
    }
    else
    {
        for (int i=k;i<len;i++)
        {
            swap(&arr[k], &arr[i] );
            perm(arr, k+1,len );
            swap(&arr[k], &arr[i] );
        }
    }

  
}

void swap(char *p,char *q){
    char c;
    c=*p;
    *p=*q;
    *q=c;