(不懂)字符串的排列

输入一个字符串，按字典序打印出该字符串中字符的全部排列。例如输入字符串 abc，则打印出由字符 a, b, c 所能排列出来的全部字符串 abc, acb, bac, bca, cab 和 cba。

 

通常思路：

正常人的思惟是，固定第一个字符，而后依次将后面的字符串与前面的交换，那么排列的个数就是除了第一个字符之外，其余字符的排列个数+1。

也就是固定一个字符串以后，以后再将问题变小，只需求出后面子串的排列个数就能够得出结果，固然第一时间想到的就是递归的算法了。

 

下面这张图很清楚的给出了递归的过程：

固定第一个位置，调换后面的位置。

很明显，递归的出口，就是只剩一个字符的时候，递归的循环过程，就是从每一个子串的第二个字符开始依次与第一个字符交换，而后继续处理子串。

还有一个问题要注意，就是若是字符串中有重复的字符串。

因为全排列就是从第一个数字起，每一个数分别与它后面的数字交换，咱们先尝试加个这样的判断——若是一个数与后面的数字相同那么这两个数就不交换 了。例如 abb，第一个数与后面两个数交换得 bab，bba。而后 abb 中第二个数和第三个数相同，就不用交换了。可是对 bab，第二个数和第三个数不一样，则须要交换，获得 bba。因为这里的bba和开始第一个数与第三个数交换的结果相同了，所以这个方法不行。

换种思惟，对abb，第一个数a与第二个数b交换获得bab，而后考虑第一个数与第三个数交换，此时因为第三个数等于第二个数，因此第一个数就再也不用与第三个数交换了。再考虑bab，它的第二个数与第三个数交换能够解决bba。此时全排列生成完毕！

 

这样，咱们获得在全排列中去掉重复的规则：

去重的全排列就是从第一个数字起，每一个数分别与它后面非重复出现的数字交换。

/**
     * 一、递归算法
     *
     * 解析：http://www.cnblogs.com/cxjchen/p/3932949.html  (感谢该文做者！)
     *
     * 对于无重复值的状况
     *
     * 固定第一个字符，递归取得首位后面的各类字符串组合；
     * 再把第一个字符与后面每个字符交换，并一样递归得到首位后面的字符串组合； *递归的出口，就是只剩一个字符的时候，递归的循环过程，就是从每一个子串的第二个字符开始依次与第一个字符交换，而后继续处理子串。
     *
     * 假若有重复值呢？
     * *因为全排列就是从第一个数字起，每一个数分别与它后面的数字交换，咱们先尝试加个这样的判断——若是一个数与后面的数字相同那么这两个数就不交换了。
     * 例如abb，第一个数与后面两个数交换得bab，bba。而后abb中第二个数和第三个数相同，就不用交换了。
     * 可是对bab，第二个数和第三个数不 同，则须要交换，获得bba。
     * 因为这里的bba和开始第一个数与第三个数交换的结果相同了，所以这个方法不行。
     *
     * 换种思惟，对abb，第一个数a与第二个数b交换获得bab，而后考虑第一个数与第三个数交换，此时因为第三个数等于第二个数，
     * 因此第一个数就再也不用与第三个数交换了。再考虑bab，它的第二个数与第三个数交换能够解决bba。此时全排列生成完毕！
     *
     *
     * @param str
     * @return
     */

public ArrayList<String> Permutation(String str){
 
        ArrayList<String> list = new ArrayList<String>();
        if(str!=null && str.length()>0){   //只要字符串不为空同时长度>0
            PermutationHelper(str.toCharArray(),0,list);
            Collections.sort(list);
        }
        return list;
    }
    private void PermutationHelper(char[] chars,int i,ArrayList<String> list){
        if(i == chars.length-1){
            list.add(String.valueOf(chars));
        }else{
            Set<Character> charSet = new HashSet<Character>();
            for(int j=i;j<chars.length;++j){
                if(j==i || !charSet.contains(chars[j])){
                    charSet.add(chars[j]);
                    swap(chars,i,j);
                    PermutationHelper(chars,i+1,list);
                    swap(chars,j,i);
                }
            }
        }
    }
 
    private void swap(char[] cs,int i,int j){
        char temp = cs[i];
        cs[i] = cs[j];
        cs[j] = temp;
    }

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

public class Solution {
    public ArrayList<String> Permutation(String str) {
        List<String> resultList = new ArrayList<>();
        if(str.length() == 0)
            return (ArrayList)resultList;
        //递归的初始值为（str数组，空的list，初始下标0）
        fun(str.toCharArray(),resultList,0);
        Collections.sort(resultList);
        return (ArrayList)resultList;
    }
     
    private void fun(char[] ch,List<String> list,int i){
        //这是递归的终止条件，就是i下标已经移到char数组的末尾的时候，考虑添加这一组字符串进入结果集中
        if(i == ch.length-1){
            //判断一下是否重复
            if(!list.contains(new String(ch))){
                list.add(new String(ch));
                return;
            }
        }else{
            //这一段就是回溯法，这里以"abc"为例
             
            //递归的思想与栈的入栈和出栈是同样的,某一个状态遇到return结束了以后，会回到被调用的地方继续执行
             
            //1.第一次进到这里是ch=['a','b','c'],list=[],i=0，我称为 状态A ，即初始状态
            //那么j=0，swap(ch,0,0)，就是['a','b','c']，进入递归，本身调本身，只是i为1，交换(0,0)位置以后的状态我称为 状态B 
            //i不等于2，来到这里，j=1，执行第一个swap(ch,1,1)，这个状态我称为 状态C1 ,再进入fun函数，此时标记为T1，i为2，那么这时就进入上一个if，将"abc"放进list中
            /////////////-------》此时结果集为["abc"]
             
            //2.执行完list.add以后，遇到return，回退到T1处，接下来执行第二个swap(ch,1,1)，状态C1又恢复为状态B
            //恢复完以后，继续执行for循环，此时j=2,那么swap(ch,1,2),获得"acb"，这个状态我称为C2,而后执行fun，此时标记为T2,发现i+1=2,因此也被添加进结果集，此时return回退到T2处往下执行
            /////////////-------》此时结果集为["abc","acb"]
            //而后执行第二个swap(ch,1,2)，状态C2回归状态B,而后状态B的for循环退出回到状态A
             
            //             a|b|c(状态A)
            //               |
            //               |swap(0,0)
            //               |
            //             a|b|c(状态B)
            //             /  \
            //   swap(1,1)/    \swap(1,2)  (状态C1和状态C2)
            //           /      \
            //         a|b|c   a|c|b
             
            //3.回到状态A以后，继续for循环，j=1,即swap(ch,0,1)，即"bac",这个状态能够再次叫作状态A,下面的步骤同上
            /////////////-------》此时结果集为["abc","acb","bac","bca"]
             
            //             a|b|c(状态A)
            //               |
            //               |swap(0,1)
            //               |
            //             b|a|c(状态B)
            //             /  \
            //   swap(1,1)/    \swap(1,2)  (状态C1和状态C2)
            //           /      \
            //         b|a|c   b|c|a
             
            //4.再继续for循环，j=2,即swap(ch,0,2)，即"cab",这个状态能够再次叫作状态A，下面的步骤同上
            /////////////-------》此时结果集为["abc","acb","bac","bca","cab","cba"]
             
            //             a|b|c(状态A)
            //               |
            //               |swap(0,2)
            //               |
            //             c|b|a(状态B)
            //             /  \
            //   swap(1,1)/    \swap(1,2)  (状态C1和状态C2)
            //           /      \
            //         c|b|a   c|a|b
             
            //5.最后退出for循环，结束。
             
            for(int j=i;j<ch.length;j++){
                swap(ch,i,j);
                fun(ch,list,i+1);
                swap(ch,i,j);
            }
        }
    }
     
    //交换数组的两个下标的元素
    private void swap(char[] str, int i, int j) {
            if (i != j) {
                char t = str[i];
                str[i] = str[j];
                str[j] = t;
            }
        }
    }