递归实现全排列，字典序法实现全排列

问题：全排列的递归实现

编程思想：

        用1 2 3为例，全排列结果为123，132，213，231，321，312  根据全排列的找到规律

       1、将当前元素与后面位置的每个元素依此交换

       2、交换后取后一个位置的元素为当前元素的位置，再执行1

       3、当当前位置是最后一个元素的位置则输出

代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class FullPermutation {

	/**
	 * @param args
	 */
	 public static void main(String[] args) { 
		 Scanner sin=new Scanner(System.in);
		 int n=sin.nextInt();
		 int[] a=new int[n];
		 for(int i=0;i<n;i++)
			 a[i]=i+1;
	        permutation(a, 0, a.length); 
	    } 
	 
	    public static void swap(int[] arr, int i, int j) { 
	        int temp = arr[i]; 
	        arr[i] = arr[j]; 
	        arr[j] = temp; 
	    } 
	 
	    // k表示当前选取的数在数组中的位置下标,m是要排列的数组的长度.  
	    public static void permutation(int[] arr, int k, int m) { 
	        // 当前位置与数组最后一个位置重合时,此时打印排列数.  
	        if (k == m - 1) { 
	            System.out.println(Arrays.toString(arr)); 
	        } else { 
	            for (int i = k; i < m; i++) { 
	                // 当前位置元素与后面位置的元素依次替换  
	                swap(arr, k, i); 
	                permutation(arr, k + 1, m); 
	                // 将位置换回来,继续做下一个排列.  
	                swap(arr, k, i); 
	 
	            } 
	        } 
	    } 

}

字典序法

引言

对一个给定数据进行全排列，在各种场合经常会用到。组合数学中，生成全排列的方法有很多，卢开澄老师的《组合数学》中就介绍了三种：序数法，字典序法，临位互换法等。其中以字典序法由于算法简单，并且使用的时候可以依照当前状态获取下一个状态，直到所有排列全部完成，方便在程序中随要随用，应用比较广泛，STL中的Next_permutation也是使用此法。

算法定义

首先看什么叫字典序，顾名思义就是按照字典的顺序（a-z, 1-9）。以字典序为基础，我们可以得出任意两个数字串的大小。比如 "1" < "12"<"13"。 就是按每个数字位逐个比较的结果。对于一个数字串，“123456789”， 可以知道最小的串是 从小到大的有序串“123456789”，而最大的串是从大到小的有序串“*987654321”。这样对于“123456789”的所有排列，将他们排序，即可以得到按照字典序排序的所有排列的有序集合。

如此，当我们知道当前的排列时，要获取下一个排列时，就可以范围有序集合中的下一个数（恰好比他大的）。比如，当前的排列时“123456879”， 那么恰好比他大的下一个排列就是“123456897”。 当当前的排列时最大的时候，说明所有的排列都找完了。

于是可以有下面计算下一个排列的算法：

设P是1～n的一个全排列:p=p1p2......pn=p1p2......pj-1pjpj+1......pk-1pkpk+1......pn

　　1）从排列的右端开始，找出第一个比右边数字小的数字的序号j（j从左端开始计算），即 j=max{i|pi<pi+1}

　　2）在pj的右边的数字中，找出所有比pj大的数中最小的数字pk，即 k=max{i|pi>pj}（右边的数从右至左是递增的，因此k是所有大于pj的数字中序号最大者）

　　3）对换pi，pk

　　4）再将pj+1......pk-1pkpk+1......pn倒转得到排列p'=p1p2.....pj-1pjpn.....pk+1pkpk-1.....pj+1，这就是排列p的下一个排列。

证明

要证明这个算法的正确性，我们只要证明生成的下一个排序是恰好比当前排列大的一个序列即可。图1.11是从卢开澄老师的《组合数学》中截取的一个有1234生成所有排序的字典序树。从左到右的每一个根到叶子几点的路径就是一个排列。下面我们将以这个图为基础，来证明上面算法的正确性。

算法步骤1，得到的子串 s = {pj+1,.....,pn}， 是按照从大到小进行排列的。即有 pj+1 > pj+2 > ... > pn， 因为 j=max{i|pi<pi+1}。

算法步骤2，得到了最小的比pj大的pk，从n往j数，第一个比j大的数字。将pk和pj替换，保证了替换后的数字比当前的数字要大。

于是得到的序列为p1p2...pj-1pkpj+1...pk-1pjpk-1...pn.注意这里已经将pk替换成了pk。

这时候我们注意到比p1..pj-1pk.....，恰好比p1....pj.....pn大的数字集合。我们在这个集合中挑选出最小的一个即时所要求的下一个排列。

算法步骤3，即是将pk后面的数字逆转一下（从从大到小，变成了从小到大。）

由此经过上面3个步骤得到的下个排列时恰好比当前排列大的排列。

同时我们注意到，当所有排列都找完时，此时数字串从大到小排列。步骤1得到的j = 0，算法结束。

代码如下：

public class DictionaryMethod {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		 Scanner sin=new Scanner(System.in);
		 int n=Integer.parseInt(sin.nextLine());    //这个地方一定要用.nextLine()，不要用.next();否则会继续读第一次读完的数字后面的空格，
		                                                                  //后面会出错，如果用.nextLine()的话，读完就到下一行了。
		 Integer[] a=new Integer[n];
		 String s=sin.nextLine();
		 String[] ss=s.split(" ");
		 for(int i=0;i<n;i++)
			 a[i]=Integer.parseInt(ss[i]);
		 Arrays.sort(a);
		 int jiecheng=1;
		 for(int i=1;i<=n;i++)
			 jiecheng*=i;
		 Integer[] anser=a;
		 print(a);
		 for(int i=0;i<jiecheng-1;i++){
			 a=nextSequence(a);
			 print(a);
		 }

	}

	private static void print(Integer[] a) {
		for(int i=0;i<a.length-1;i++)
			System.out.print(a[i]+" ");
		System.out.println(a[a.length-1]);
		
	}

	private static Integer[] nextSequence(Integer[] a) {
		String ret=null;
		if(a==null)
		return null;
		int j=a.length-2;
		while(j>=0&&a[j]>a[j+1])
			j--;
		if(j<0)
			return null;
		int k=a.length-1;
		while(a[k]<a[j])
			k--;
		int temp=a[j];
		a[j]=a[k];
		a[k]=temp;
		int low=j+1;
		int high=a.length-1;
		while(low<high){
			int temp2=a[low];
			a[low]=a[high];
			a[high]=temp2;
			low++;
			high--;
		}
		return a;
	}

}

但是上述代码在序列有重复数字的时候，字典顺序会出错，会有重复的序列，并且还会漏掉序列。。。寻找办法中。。