全排列

全排列：abc全排列为 abc,acb,bca,bac,cba,cab.
方法一：

import java.util.ArrayList;

public class 全排列 {
	public static void main(String[] args) {
		ArrayList<String> res=new 全排列().f1("abc");
		System.out.println(res.size());
		System.out.println(res);
	}
	public ArrayList<String> f1(String A){
		int n=A.length();
		ArrayList<String> res=new ArrayList<String>();
		res.add(A.charAt(0)+"");
		//第二个字符插入到前面生成集的每一个元素里面
		for(int i=1;i<n;i++) {
			ArrayList<String> res_new=new ArrayList<String>();
			char c=A.charAt(i);
			for(String str:res) {
				//插入到每个位置形成一个新串
				String newStr=c+str;//加在前面
				res_new.add(newStr);
				newStr=str+c;//加在后面
				res_new.add(newStr);
				//放到中间，插空放。
				for(int j=1;j<str.length();j++) {
					newStr=str.substring(0, j)+c+str.substring(j);
					res_new.add(newStr);
				}
			}
			res=res_new;
		}
		return res;
	}
}

方法二：（数组内部交换，回溯）交换法
思想是在数组中，打乱顺序重排，分别考虑当a打头时，b打头时，c打头时的情况。
一定要注意，走第二条分路时（考虑完a打头时，转回去考虑b时，）一定要在最开始恢复一下原来的状态，这是因为数组的空间是共享的，考虑完一遍，顺序已经打乱了。
难点：1，怎么考虑多分支（a，b，c等等的每一条分支）
2，恢复状态
3，顺序是先纵后横（即先走完递归还是先遍历i）。顺序是i一定下来，先走完里面的递归，再i++。就是把每一个开头字母先走完，比如先走完以a开头的，再考虑b。

import java.util.ArrayList;
import java.util.Arrays;

public class 全排列02 {
	public static void main(String[] args) {
		ArrayList<String> res=new 全排列02().f2("abc");
		System.out.println(res.size());
		System.out.println(res);
	}
	ArrayList<String> res=new ArrayList<String>();
	public ArrayList<String> f2(String a){
		char[] arr=a.toCharArray();
		Arrays.sort(arr);
		getf2(arr,0);
		return res;
	}
	private void getf2(char[] arr,int k) {
		if(k==arr.length) {//排好了一种情况，递归的支路走到底了
			res.add(new String(arr));
		}
		//从k位开始的每个字符，都尝试放在新排列的k这个位置
		for(int i=k;i<arr.length;i++) {
			swap(arr,k,i);//把后面每个字符换到k位
			getf2(arr,k+1);//排剩下的那段
			swap(arr,k,i);//回溯
		}
	}
	static void swap(char[] arr,int i,int j) {
		char tmp=arr[i];
		arr[i]=arr[j];
		arr[j]=tmp;
	}
}

方法三：（前缀法）取出第k个全排列后的字符串。
每次都从头扫描，只要该字符可用，我们就附加到前缀中后面，前缀就变长了，然后把变长的前缀继续递归下去。
因为字符集是有序的，所以从头往后扫再加进去，得到的结果也是有序。当前缀长度等于字符集长度时，说明已经全部添加完毕，一个排列就完成了。我们就可以计数，然后把第k个返回。
注意：若有重复字符（如aabc），则递归永远没法输出。（重复就不能加进去，这样的话，前缀的长度就永远不能和字符串的长度相等），所以改进方法为，让加进去的前缀中的数量小于总的字符串的数量就好。

public class 全排列03 {
	//全排列后取出第k个
	final static int k=4;
	static int count=0;
	public static void main(String[] args) {
		String s="123";
		f3("",s.toCharArray());
	}
	private static void f3(String prefix,char[] arr) {
		//如果前缀的长度==字符集的长度，一个排列就完成了
		if(prefix.length()==arr.length) {
			count++;
			if(count==k) {
				System.out.println(prefix);
				System.exit(0);
			}
		}
		//每次都从头扫描，只要该字符可用，我们就附加在前缀后面，前缀变长再递归
		for(int i=0;i<arr.length;i++) {
			char ch=arr[i];
			//这个字符可用：在前缀中出现的次数<在字符集中出现的次数
			if(count(prefix.toCharArray(),ch)<count(arr,ch)) {
				f3(prefix+ch,arr);
			}
		}
	}
	
	private static int count(char[] arr,char ch) {
		int cnt=0;
		for(char c:arr) {
			if(c==ch)  cnt++;
		}
		return cnt;
	}
}

三种方法的比较和总结：
交换法：简便，易懂，写起来简单。能够自然地处理重复。但是 无法维持字典序。
前缀法：代码较多，可以维护字典序，但是要人为去重。