全排列 （遞歸求解+字典序） java 轉載

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

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

一、字典序法：

如何計算字符串的下一個排列了？來考慮"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");
    }

}

二、遞歸法

爲方便起見，用123來示例下。123的全排列有12三、13二、21三、23一、3十二、321這六種。首先考慮213和321這二個數是如何得出的。顯然這二個都是123中的1與後面兩數交換獲得的。而後能夠將123的第二個數和每三個數交換獲得132。同理能夠根據213和321來得231和312。所以能夠知道——全排列就是從第一個數字起每一個數分別與它後面的數字交換。

因爲全排列就是從第一個數字起每一個數分別與它後面的數字交換。咱們先嚐試加個這樣的判斷——若是一個數與後面的數字相同那麼這二個數就不交換了。如122，第一個數與後面交換得2十二、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");
    }

}