全排列算法（递归和字典）

一个算法命题：给定字符串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;
    }
    
}