27_PermutationString

Permutation:排列
图解：

package swordToOffer._27_PermutationString;

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


/*
题目描述：
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,
则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
*/

/*
思路详解：牛客网上的复制（比较难，好好思考）

这一段就是回溯法，这里以"abc"为例

递归的思想与栈的入栈和出栈是一样的,某一个状态遇到return结束了之后，会回到被调用的地方继续执行

1.第一次进到这里是ch=['a','b','c'],list=[],i=0，我称为 状态A ，即初始状态
那么j=0，swap(ch,0,0)，交换(0,0)位置之后的状态我称为 状态B。就是['a','b','c']，
进入递归fun，自己调自己，只是i为1，此时已进入第二层（共三层）。

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)，即"cba",这个状态可以再次叫做状态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循环，结束。*/
public class Solution {

    public ArrayList<String> Permutation(String str) {
        ArrayList<String> res = new ArrayList<>();
        fun(str.toCharArray(),res,0);
        //还要进行排序
        Collections.sort(res);
        return res;

    }

    public void fun(char[] ch, List<String> list, int i) {
        //递归结束条件，如果已经递归到最后一个字符，就不用再递归了,开始处理数据
        if (i == ch.length - 1) {
            //如果不重复，则加入
            if (!list.contains(new String(ch))) {
                list.add(new String(ch));
            }
            return;
        }
       
     //第一层for循环：swap(0,0)操作后，固定字符串首字符(如a)，j++后,经过swap(0,1)，
        // 首字符就变化成下一个字符(如b),共需swap(0,0),swap(0,1),swap(0,2)
        for (int j = i; j < ch.length; j++) {
            //交换i,j字符位置
            swap(ch, i, j);
            //第一个已经固定好，进一步递归固定第2个首字符，共swap(1,1),swap(1,2).
            // 第3个时i=ch.length-1,进入if返回
            fun(ch, list, i + 1);
            //变化回原来的顺序，使返回上一个递归时，字符串位置是正确的
            swap(ch, i, j);

        }


    }

    private void swap(char[] ch, int i, int j) {
        char temp = ch[i];
        ch[i] = ch[j];
        ch[j] = temp;
    }
}