全排列算法（遞歸和字典）

一個算法命題：給定字符串S[0…N-1]，設計算法，枚舉S的全排列。如：123，全排列就是：123,132,213,231,312,321

個人愚昧，搞了一天半，才終於把字典排列搞出來，看不到大神寫的代碼，我的代碼還有很多優化之處，先記錄下，遞歸現在還是有點蒙。

 

java代碼：遞歸實現（考慮有重復的字符）

以字符串1234為例：
1 – 234
2 – 134
3 – 214
4 – 231
如何保證不遺漏： 每次遞歸前，保證1234的順序不變。

 

package stringtest;
import java.util.ArrayList;
import java.util.Collections;

/**題目描述
    輸入一個字符串,按字典序打印出該字符串中字符的所有排列。
    例如輸入字符串abc,則打印出由字符a,b,c所能排列出來的所有字符串abc,acb,bac,bca,cab和cba。
    輸入描述:
    輸入一個字符串,長度不超過9(可能有字符重復),字符只包括大小寫字母。
 * 
 * 
 * @author Administrator
 *
 */
public class FullArray {

    public static void main(String[] args) {
        FullArray fa = new FullArray();
        String str = "abc";
        ArrayList<String> arrayList = fa.Permutation(str);
        for (String string : arrayList) {
            System.out.println(string);
        }
    }

    /**
     * 思路：利用遞歸的思想。來實現
     * 先讓a第一位：剩余bcd做全排列
     * 先讓b第一位：剩余acd做全排列
     * 先讓c第一位：剩余abc做全排列
     * 先讓d第一位：剩余abc做全排列
     * 
     * @param str
     * @return
     */
    ArrayList<String> list = new ArrayList<>();
    public ArrayList<String> Permutation(String str) {
        char[] array = str.toCharArray();
        permutaionTest(array,0,str.length()-1);
        Collections.sort(list);
        return list;
    }
    
    public void permutaionTest(char[] array,int start,int end){
        //遞歸退出條件
        if(array.length<1){
            return;
        }
        //如果start和end不相等，說明完成一次排序
        if(start==end){
            String val = new String(array);
           //這里也是判斷元素重復情況(方式一)
            if (!list.contains(val))
                list.add(val);
        }else{
            //回溯法，每次固定一個元素在最前面，后面元素進行全排列
            for (int i = start; i <= end; i++) {
       
               //考慮有重復元素的情況(方式二)
                boolean flag = true;
                for (int j = start; j < i; j++) {
                    if(array[j] == array[i]){//這里吧i換成end也行
                        flag = false;
                    }
                }
                
                //有重復元素就跳過大循環，下一個比較
                if(flag){
                    swap(array,start,i);
                    permutaionTest(array,start+1,end);
                    swap(array,i,start);
                }
            }
        }
    }

    private void swap(char[] array, int start, int i) {
        if(start!=i){
            char tmp = array[start];
            array[start] = array[i];
            array[i] = tmp;
        }
    }
}

 

java代碼：字典序排列（考慮有重復的字符）

全排列的非遞歸算法：整理成算法語 步驟：后找、小大、交換、翻轉——
 后找：字符串中最后一個升序的位置i，即S[k]>S[k+1](k>i)，S[i]<S[i+1]；
 查找(小大)：S[i+1…N-1]中比Ai大的最小值（補充：根據規律，好像只要從右往左找第一個比Ai大的值就行。）
 交換：Si，Sj；
 翻轉：S[i+1…N-1]

個人總結：以926520為例
①：字符串從后往前找，找到第一個降序的值為2，位置為1
②：然后找出2和后面比2大的數的最小值為5（補充：從右往左找第一個比2大的值為5。）
③：2和找出的5進行位置交換
④：把2后面所有的數進行翻轉

最后大功告成：
第一步：先把字符串進行全排序

 

package com.qyzx.string;

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

public class AllArray2 {

    public static void main(String[] args) {
        String str = "1212";
        char[] arr = str.toCharArray();
        //先對數組進行重小到大進行排序
        Arrays.sort(arr);
        fullArray(arr,0,arr.length-1);
    }

    /**
     * 該方法是對字符串進行全排列
     * 
     * @param arr
     * @param i
     * @param j
     */
    private static boolean fullArray(char[] arr, int start, int end) {
        if(end<1){
            return true;
        }
        while(true){
            System.out.println(arr);
            //①：從后往前找，找出第一個降序的值
            int first = end;
            for (int i = end; i >= 1; i--) {
                if(arr[i-1]<arr[i]){
                    first = i-1;
                    break;
                }else if(i==1){
                    //說明已經排好序了，沒有降序的值。
                    return false;
                }
            }
//            System.out.println("第一個降序的值n："+arr[first]+"，first下標："+first);
            //②：找出first后面比first大的數
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = first+1; i < end+1; i++) {
                if(arr[first]<arr[i]){
                    list.add(i);
                }
            }
            //比first大的數的最小值
            int min = list.get(0);
            for (int i = 1; i < list.size(); i++) {
                if(arr[min]>arr[list.get(i)]){
                    min = list.get(i);
                }
            }
//            System.out.println("比n大的最小值m："+arr[min]+"，min下標："+min);
            //③：然后交換min和first的位置
            swap(arr,min,first);
            //④：因為交換了位置，所以現在的min就是之前的first，把min后面所有的字符串進行反轉
//            System.out.println("n后面數字進行翻轉前："+String.valueOf(arr));
            resver(arr,first+1,end);
//            System.out.println("n后面數字進行翻轉后："+String.valueOf(arr));
        }
    }
    
    //實現arr數組的s位置到end位置的翻轉
    private static void resver(char[] arr, int start, int end) {
        while(start<end){
            //可以把最后賦值給前面
            char temp1 = arr[start];
            arr[start++] = arr[end];
            arr[end--] = temp1;
        }
    }

    //進行元素之間交換位置
    public static void swap(char[] arr,int from ,int to){
        char s = arr[from];
        arr[from] = arr[to];
        arr[to] = s;
    }
    
}