字符串的全排列问题

题目：

　　编写一个方法，确定某字符串的所有排列组合。

　　解法一：

　　　　

　　代码：

import java.util.ArrayList;

public class 全排列1 {

    public static void main(String[] args) {
        ArrayList<String> res = getPermutation0("abcd",4-1);
        System.out.println(res.size());
        System.out.println(res);
        System.out.println("=====================================");
        res = getPermutation1("abcd");
        System.out.println(res.size());
        System.out.println(res);
    }
    
    // 迭代法的递归形式
    public static ArrayList<String> getPermutation0(String A,int n){
        if (n==0) {
            ArrayList<String> res = new ArrayList<>();
            res.add(A.charAt(n)+"");
            return res;
        }
        ArrayList<String> res = getPermutation0(A, n-1);
        char c = A.charAt(n);
        ArrayList<String> res_new = new ArrayList<>();
        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);
            }
        }
        return res_new;
    }
    
    /*逐步生成大法-迭代法*/
    public static ArrayList<String> getPermutation1(String A) {
        int n = A.length();
        ArrayList<String> res = new ArrayList<>();
        res.add(A.charAt(0) + "");// 初始化,包含第一个字符

        for (int i = 1; i < n; i++) {// 第二个字符插入到前面生成集合的每个元素里面
            ArrayList<String> res_new = new ArrayList<>();
            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;
    }

}

　　结果：

　　　　

 　　解法二：交换法，大体意思就是不开辟新的辅助空间，直接在原有的数组中进行两个元素的交换即可，但是要注意这种方法必须要进行回溯。

　　 代码：

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

public class 全排列2 {

    public static void main(String[] args) {
        ArrayList<String> res = getPermutation("123");
        System.out.println(res.size());
        System.out.println(res);
    }

    static ArrayList<String> res = new ArrayList<>();

    public static ArrayList<String> getPermutation(String A) {
        char[] arr = A.toCharArray();
        Arrays.sort(arr);// abc
        getPermutationCore(arr, 0);
        return res;
    }

    private static void getPermutationCore(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位
            getPermutationCore(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;
    }

}

　　结果：

　　　　

例题：

　　LeetCode60 n个数的排列组合找出第k个排列。

　　思路：在上面的代码中我们虽然已经完成了n的元素的全排列，可是它的结果并不是按照字典序排列，那对于这道题目来说，按照上面的思路就很难完成了，当然我们也可以对上面的解法的答案再进行排序，这也算是一种方法。这里要介绍的是一种叫做前缀法的方法。思路就是每次从头顺序扫描源数组（当然要先把源数组排序），只要该元素不在前缀里面，那么就把这个元素附加到前缀的后面形成新的前缀，直到这个前缀的长度等于源串的长度就不再继续加下去了。然后继续这样循环下去就能得到按照字典序排列的全排列，在循环过程中依次计数即可，这样就能找出第k个排列了。

　　代码：

public class 全排列3 {

    public static void main(String[] args) {
        String s = "123";
        permutation("", s.toCharArray());
    }

    final static int k = 3;
    static int count = 0;

    private static void permutation(String prefix, char[] arr) {
        if (prefix.length() == arr.length) {// 前缀的长度==字符集的长度,一个排列就完成了
            // System.out.println(prefix);
            count++;
            if (count == k) {
                System.out.println("-------:" + prefix);
                System.exit(0);
            }
        }
        // 每次都从头扫描,只要该字符可用,我们就附加到前缀后面,前缀变长了
        for (int i = 0; i < arr.length; i++) {
            char ch = arr[i];
            // 这个字符可用:在pre中出现次数<在字符集中的出现次数 以防有元素重复的情况
            if (count(prefix, ch) < count(arr, ch)) {
                permutation(prefix + ch, arr);
            }
        }
    }

    private static int count(char[] arr, char ch) {
        int cnt = 0;
        for (char c : arr) {
            if (c == ch)
                cnt++;
        }
        return cnt;
    }

    private static int count(String str, char ch) {
        int cnt = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == ch)
                cnt++;
        }
        return cnt;
    }

}

　　结果：