兩種常用的全排列算法(java)

問題：給出一個字符串，輸出所有可能的排列。

全排列有多種算法，此處僅介紹常用的兩種：字典序法和遞歸法。

1、字典序法：

如何計算字符串的下一個排列了？來考慮"926520"這個字符串，我們從后向前找第一雙相鄰的遞增數字，"20"、"52"都是非遞增的，"26 "即滿足要求，稱前一個數字2為替換數，替換數的下標稱為替換點，再從后面找一個比替換數大的最小數（這個數必然存在），0、2都不行，5可以，將5和2交換得到"956220"，然后再將替換點后的字符串"6220"顛倒即得到"950226"。

算法概括：從后向前遍歷，找出第一個交換點，再按照規則找出第二個交換點，將兩者進行交換，對第一個交換點之后的字符進行顛倒操作

package algorithm;

import java.util.Arrays;

public class DictionaryPermutation {

    private char[] data;
    private int length;

    public void permutate(String input) {
        // change the data type to we needed
        changeToData(input);
        // sort the data from small to big
        Arrays.sort(data);
        // output all the order
        System.out.println(data);
        while (nextPermutate()) {
            System.out.println(data);
        }
    }

    private void changeToData(String input) {
        if (input == null)
            return;
        data = input.toCharArray();
        length = data.length;
    }

    private boolean nextPermutate() {
        int end = length - 1;
        int swapPoint1 = end, swapPoint2 = end;
        // the actual swap-point is swapPoint1 - 1
        while (swapPoint1 > 0 && data[swapPoint1] <= data[swapPoint1 - 1])
            swapPoint1--;
        if (swapPoint1 == 0)
            return false;
        else {
            while (swapPoint2 > 0 && data[swapPoint2] <= data[swapPoint1 - 1])
                swapPoint2--;
            swap(data, swapPoint1 - 1, swapPoint2);
            reverse(data, swapPoint1, end);
            return true;
        }
    }

    private void swap(char[] data, int left, int right) {
        char temp = data[left];
        data[left] = data[right];
        data[right] = temp;
    }

    private void reverse(char[] data, int left, int right) {
        for (int i = left, j = right; i < j; i++, j--)
            swap(data, i, j);
    }

    public static void main(String... args) {
        DictionaryPermutation p = new DictionaryPermutation();
        p.permutate("aab");
    }

}

2、遞歸法

為方便起見，用123來示例下。123的全排列有123、132、213、231、312、321這六種。首先考慮213和321這二個數是如何得出的。顯然這二個都是123中的1與后面兩數交換得到的。然后可以將123的第二個數和每三個數交換得到132。同理可以根據213和321來得231和312。因此可以知道——全排列就是從第一個數字起每個數分別與它后面的數字交換。

由於全排列就是從第一個數字起每個數分別與它后面的數字交換。我們先嘗試加個這樣的判斷——如果一個數與后面的數字相同那么這二個數就不交換了。如122，第一個數與后面交換得212、221。然后122中第二數就不用與第三個數交換了，但對212，它第二個數與第三個數是不相同的，交換之后得到221。與由122中第一個數與第三個數交換所得的221重復了。所以這個方法不行。

換種思維，對122，第一個數1與第二個數2交換得到212，然后考慮第一個數1與第三個數2交換，此時由於第三個數等於第二個數，所以第一個數不再與第三個數交換。再考慮212，它的第二個數與第三個數交換可以得到解決221。此時全排列生成完畢。
這樣我們也得到了在全排列中去掉重復的規則——去重的全排列就是從第一個數字起每個數分別與它后面非重復出現的數字交換。

（描述從http://blog.csdn.net/hackbuteer1/article/details/6657435處轉載）

package algorithm;

public class RecursionPermutation {

    public static void permutate(String input){
        if(input == null)
            throw new IllegalArgumentException();
        char[] data = input.toCharArray();
        permutate(data, 0);
    }
    
    public static void permutate(char[] data, int begin){
        int length = data.length;
        if(begin == length)
            System.out.println(data);
        for(int i = begin ; i < length; i++)
        {
            if(isUnique(data, begin, i)){
                swap(data, begin, i);
                permutate(data, begin + 1);
                swap(data, begin, i);
            }                
        }
    }
    
    private static boolean isUnique(char[] data, int begin, int end){
        for(int i = begin; i < end; i++)
            if(data[i] == data[end])
                return false;
        return true;
    }
    
    private static void swap(char[] data, int left, int right) {
        char temp = data[left];
        data[left] = data[right];
        data[right] = temp;
    }
    
    
    public static void main(String... args){
        RecursionPermutation.permutate("aac");
    }

}