字符串的全排列問題

題目：

　　編寫一個方法，確定某字符串的所有排列組合。

　　解法一：

　　　　

　　代碼：

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;
    }

}

　　結果：