转载整理：求数组的全排列

对一个数组内的数进行全排列（递归方法）

//: ArrayCombination.java

public class ArrayCombination {

    static int a [] = {1, 2, 5};
    static int count = 0;

    public static void main(String[] args) {
        permutation(0, a.length-1);
        System.out.println("一共有" + count + "种组合");
    }

    public static void permutation(int m, int n) {
        int i;
        if (m == n) {
            display(a);
            count++;
        }
        for (i = m; i <= n; i++) {
            swapInArray(i,m);
            permutation(m + 1, n);
            swapInArray(i,m);
        }
    }

    public static void display(int[] array) {
        for (int i : array) {
            System.out.print(i);
        }
        System.out.println();
    }

    public static void swapInArray(int x,int y){
        int temp = a[x];
        a[x] = a[y];
        a[y] = temp;       
    }
}
/*Output:
135
153
315
351
531
513
一共有6种组合
*//:~

参考：
1.bbc.csdn:列出四个数的所有排列组合
算法重点在permutation内的for循环，通过交换数组的元素后再调用permutation操作，最终使得数组内的数字在每个位置都出现一次，即实现了全排列。这个例子还不够直观明了，下面摘录另一个人的博客里的一些内容：
2.blog.sina:递归实现全排列

”打印数组a{1,2,…,n}的全排列

递归思想：
取出数组中第一个元素放到最后，即a[1]与a[n]交换，然后递归求a[n-1]的全排列

1）如果数组只有一个元素n=1，a={1} 则全排列就是{1}
2）如果数组有两个元素n=2，a={1,2} 则全排列是
{2,1}–a[1]与a[2]交换。交换后求a[2-1]={2}的全排列，归结到1)
{1,2}–a[2]与a[2]交换。交换后求a[2-1]={1}的全排列，归结到1)
3）如果数组有三个元素n=3，a={1,2,3} 则全排列是
{{2,3},1}–a[1]与a[3]交换。后求a[3-1]={2,3}的全排列，归结到2）
{{1,3},2)–a[2]与a[3]交换。后求a[3-1]={1,3}的全排列，归结到2）
{{1,2},3)–a[3]与a[3]交换。后求a[3-1]={1,2}的全排列，归结到2）
…
以此类推。“

再简单地说， 对abc进行全排列，那么可以看做：（ab的全排列+c）和 （ac的全排列+b）和（bc的全排列+a）三个的组合 （见3.csdn：递归思想实现全排列 ）

//: 代码如下，其余完全相同，不再粘贴

    public static void main(String[] args) {
        permutation(a.length);
    }


    static void permutation(int size){
        if(size == 1){
            display(a);
        }
        else{
            for(int i = 0;i < size;i ++){
                swapInArray(i,size - 1);
                permutation(size - 1);
                swapInArray(i,size - 1);
            }
        }
    }
/*Output：
351
531
513
153
315
135
*/

可以看出，第一个程序输出结果更加美观些。

关于其他的（非递归）方法，建议看看这篇：
4.cnblogs：全排列各种实现（非递归、递归）

3/18/15补充：
昨晚想了一下，前面说到的“可以看出，第一个程序输出结果更加美观些。”有点不对，两个程序只是不同的实现罢了，没有优劣之分。只是实现时考虑角度有点差异，简单介绍如下：

对于 a[] = {1 ,3 ,5}，第一种是把 a 看作 {{1}，{3，5}}，再对{3，5}进行操作。
第二种是把 a 看作{{1，3}，5}，先对{1，3}进行操作。

所以，两者只是同一算法的不同实现罢了 =.=