剑指offer第二十七题字符串的排列

题目描述

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

原文：https://www.nowcoder.com/questionTerminal/fe6b651b66ae47d7acce78ffdd9a96c7?f=discussion

基于回溯法思想：

小知识：idea快速替换空行

替换快捷键Ctrl + R，输入正则表达式：^\s*\n，选中Regex，点击Replace all.

转移字符	含义
^	否
*	0个或多个
\s	字符串
\n	换行(LF) ，将当前位置移到下一行开头

package test;

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

class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> resultList = new ArrayList<>();//这里改为ArrayList也可以ac
        if(str.length() == 0)
            return resultList;
        //递归的初始值为（str数组，空的list，初始下标0）注意中英文的逗号
        //先把fun(0)写上，然后再添加初始值str.toCharArray()，再添加最终值resultList
        fun(str.toCharArray(),resultList,0);//toCharArray() 方法将字符串转换为字符数组。
        Collections.sort(resultList);
        return resultList;
    }

    private void fun(char[] ch,ArrayList<String> list,int i){//不要忘了int
        //这是递归的终止条件，就是i下标已经移到char数组的末尾的时候，考虑添加这一组字符串进入结果集中
        if (i == cha.length - 1 && !list.contains(new String(cha))) {
            list.add(new String(ch));//这里是加字符串啊，不是加list，醉了
            System.out.println("list的变化过程："+list);
            return;
        }
        /*
        //这一段就是回溯法，这里以"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);//固定第一个字符，交换字符数组ch的后面两个
            fun(ch,list,i+1);//固定第一个字符，求后面字符的排列（即：在第1步的遍历过程中，插入递归进行实现）。
            swap(ch,i,j);//回溯，就是将i和j再调换回来
        }
    }
    //交换数组的两个下标的元素
    private void swap(char[] str, int i, int j) {//这里是形参啊，要定义的！！！
        if (i != j) {//这里不是str[i] != str[j]!
            char t = str[i];//这里不能用加和异或的方法求，因为这是字符串
            str[i] = str[j];
            str[j] = t;
        }
    }
}
public class Main{
    public static void main(String[] args) {
        Solution p = new Solution();
        ArrayList<String> t = p.Permutation("cba");
        System.out.println(t.toString());
    }
}