字符串的排列

题目：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。 结果请按字母顺序输出。

输入描述：输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

递归是个容易想到的思路，每个递归，我决定一个位置该放那个字符。

然后想，这个递归函数，我需要哪些输入？
1. 一个排好序的字符数组char[] chars。按字典序排列，比如A<a<B。
2. 一个标记数组boolean[] mark。在每个位置，我都要试过所有未被标记的不重复的字符。注意，重复字符的位置一定是连续的。
3. 要决定字符的位置int i，从0开始。
4. 存放字符串的ArrayList<String> strs。只有当i==mark.length-1的时候，字符串才算构造完成。
5. 已构造的局部字符串String current。

想清楚需要哪些东西后，算法也就清楚了：

import java.util.ArrayList;
public class Solution {
    // 排序字符们
    private static void sort(char[] chars) {
        if(chars.length==1) return;
        for(int p=1; p<chars.length; p++) {
            for(int j=p-1; j>=0; j--) {
                if(compare(chars[p],chars[j])){
                    char tmp = chars[p];
                    chars[p] = chars[j];
                    chars[j] = tmp;
                }
            }
        }
    }

    private static boolean compare(char a, char b) {
        char aa = Character.toLowerCase(a);
        char bb = Character.toLowerCase(b);
        if(aa==bb) return a<b;
        else return aa<bb;
    }

    public static ArrayList<String> Permutation(String str) {
        ArrayList<String> strs = new ArrayList<String>();
        if(str.length()==0) return strs;
        char[] chars = str.toCharArray();
        sort(chars);
        boolean[] mark = new boolean[chars.length];
        for(int i=0; i<chars.length; i++)
            mark[i] = false;
        perm(chars, mark, 0, strs, "");
        return strs;
    }

    private static void perm(char[] chars, boolean[] mark, 
            int i, ArrayList<String> strs, String current) {
        if(i==chars.length-1) { // the last position
            int j = 0;
            while(mark[j]!=false) j++;
            String done = current+chars[j];
            strs.add(done);
            return;
        }
        else {
            /*for(int j=0; j<mark.length; j++) {
                if(mark[j]==false) {
                    String notyet = current+chars[j];
                    mark[j] = true;
                    perm(chars, mark, i+1, strs, notyet);
                    mark[j] = false;
                }
            }*/
            int j=0;
            while(j<mark.length) {
                if(mark[j]==false) {
                    char now = chars[j];
                    String notyet = current+now;
                    mark[j] = true;
                    // 为每一种不同的尝试继续构造下去
                    perm(chars, mark, i+1, strs, notyet);
                    // 试过后，将mark改回，以便供还没试过该字符的串串一个机会
                    mark[j] = false;
                    // 跳过和当前字符相同的连续字符
                    while(j<mark.length && chars[j]==now) j++;
                    if(j==mark.length) return;
                }
                else j++;
            }
        }
    }
}

递归思考是最有条理最有乐趣的思考。