《剑指offer》刷题——【分解让复杂问题简单化】面试题38：字符串的排列（java实现）

一、题目描述

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

二、题目分析

• 把一个字符串看成两部分：1）第一个字符；2）后面所有的字符
• 先求出所有可能出现在第一个位置的字符，即把第一个字符和后面所有的字符交换
• 固定第一个字符，求后面所有字符的排列
• 求后面的字符依旧分成第一个字符和后边的所有字符
• 以此递归，直到最后只剩下最后一个字

参考牛客

• 找全排列类似于深度优先遍历，深度优先最关键的就是要记住上一个状态，而所谓回溯就是要回到上一没有操作过的状态，再去考虑别的情况。上图每次都把一个数固定在前面，让后面的数递归地进行全排列，这样每个数都固定过以后就能找出所有排列。关键的地方在于，我们把每个数固定在前面并让后面的进行全排列完毕以后，要恢复原来的状态，也就需要交换回来。

三、代码实现

import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> result = new ArrayList<>();//所有排列的可能
        if(str !=null || str.length()>0){
            help(0,str.toCharArray(),result);
            Collections.sort(result);
        }
        return result;  
    }
    
    /**
    * 递归全排列
    */
    public static void help(int i, char[] cha, ArrayList<String> result){
        //字符串末尾
        if(i==cha.length-1){
            //将字符数组转化成字符串
            String val = String.valueOf(cha);
            //如果当前排列未在result中，则添加
            if(!result.contains(val)){
                result.add(val);
            }
        }
        else{
            for(int j=i; j<cha.length; j++){
                swap(i,j,cha);//依次选一个数固定住
                help(i+1, cha, result);//让后面的进行全排列
                swap(i,j,cha);//恢复原来的，回溯
            }
        }
    }
    
    /**
    *字符交换
    */
    public static void swap(int i, int j, char[] cha){
        char temp = cha[i];
        cha[i] = cha[j];
        cha[j] = temp;
    }
}

参考博文

四、完整代码及扩展代码

• 字符串的排列

package Permutation;

/**
 * @Description:
 * @Author: hw
 * @Date: 2019/7/3 16:50
 */

import java.util.*;

public class PermutationString {
    public void Permutation(String str) {
        //字符串转化为字符数组
        char[] arrays=str.toCharArray();
        //全排列
        permutation(arrays,0,arrays.length);
    }
    // 方法参数 1数组  2起始位置  3数据长度
    private void permutation(char[] arrays,int start,int length) {
        if (length==1) //数据长度为1时，数组输出
        {System.out.println(Arrays.toString(arrays));}

        else{
            for(int i=start;i<start+length;i++){
                //固定第一个字符
                swap(arrays,start,i);
                //剩余字符全排列
                permutation(arrays,start+1,length-1);
                //回溯
                swap(arrays,start,i);//切记一定要换回，否则影响下次的循环交换。
            }
        }
    }


    private void swap(char[] arrays, int start, int i) {
        // TODO Auto-generated method stub
        char temp=arrays[start];
        arrays[start]=arrays[i];
        arrays[i]=temp;
    }
    public static void main(String[] args) {
        PermutationString one=new PermutationString();
        one.Permutation("abc");
    }
}

• 字符的所有组合

package Permutation;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @Description: 求字符的所有组合
 * @Author: hw
 * @Date: 2019/7/3 16:53
 */
public class PermutaionRanNum {

    private static void  Combination(char[] chs, int m, int pos, List<Character> list){
        //字符数组为空
        if(chs==null){
            return;
        }
        //组合长度为0
        if(m==0){
            System.out.println(list.toString());
            return;
        }
        //遍历到字符数组末尾
        if(pos==chs.length){
            return;
        }
        //选择首字符
        list.add(chs[pos]);
        //在剩余的字符里选取m-1个字符
        Combination(chs,m-1,pos+1,list);
        //不选择首字符
        list.remove((Character)chs[pos]);
        //在剩余的字符里选取m个字符
        Combination(chs,m,pos+1,list);
    }

    public static void main(String[] args) {
        System.out.print("Please input string:");
        //从命令行窗口得到用户输入的字符串
        String str = new Scanner(System.in).next();
        //将字符串转化为字符数组
        char[] chs = str.toCharArray();
        //实例化list,泛型Character
        List list = new ArrayList<Character>();

        for(int m=1;m<=chs.length;m++){
            Combination(chs,m,0,list);
        }
    }
}