剑指Offer:字符串的排列

最新推荐文章于 2022-02-28 18:20:11 发布

原创最新推荐文章于 2022-02-28 18:20:11 发布 · 169 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #剑指Offer #字符串 #全排列 #递归

JAVA 专栏收录该内容

20 篇文章

订阅专栏

本文介绍了一种使用递归实现的字符串全排列算法，通过确定首个字符并递归求解剩余字符的排列，最终生成字符串的所有可能排列。文章提供了详细的代码实现，并通过案例测试验证了算法的正确性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

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

基本思路

1、要想求得字符串的全排列，首先确定第一个字符，然后求剩下字符的全排列

2、要想求得剩下字符的全排列，则需要确定剩下字符的第一个字符，然后再求剩下字符除去第一个字符的全排列（跟步骤1一样）

3、如何确定第一字符：由于每一个字符都可能成为第一个字符，因此需要第一个字符与剩余字符交换

代码实现

package leetcode.recursive;

import java.util.*;

/**
 * @基本功能:打印输出字符串的全排列
 * @program:summary
 * @author:peicc
 * @create:2019-08-02 18:09:16
 **/
public class PermutationForString {
    public static ArrayList<String> Permutation(String str) {
        ArrayList<String> list=new ArrayList<String>();
        if(str!=null){
            Permutation1(str.toCharArray(),0,list);
            Collections.sort(list);
        }
        return list;
    }
    //递归函数的功能：得到字符串从i开始的全排列
    /**
     * @功能：基本思路：1、要想求得字符串的全排列，首先确定第一个字符，然后求剩下字符的全排列
     *               2、要想求得剩下字符的全排列，则需要确定剩下字符的第一个字符，然后再求剩下字符除去第一个字符的全排列（跟步骤1完成的功能一样）
     *               3、如何确定第一字符：由于每一个字符都可能成为第一个字符，因此需要第一个字符与剩余字符交换
     * @Param: [chars, i, list]
     * @return: void
     * @Date: 2019/8/2
     */
    public static void Permutation1(char[] chars,int i,ArrayList<String> list){
        //递归出口：字符串的最后一位
        if(i==chars.length-1){
            list.add(String.valueOf(chars));
        }else{
            Set<Character> set=new HashSet<Character>();//储存出现的每个字符，用来判断字符是否重复
            for(int j=i;j<chars.length;j++){
                if(!set.contains(chars[j])){
                    set.add(chars[j]);
                    swap(chars,i,j);//确定第一个字符
                    PermutationHelper(chars,i+1,list);//递归得到取得首位后的字符串的各种组合
                    swap(chars,j,i);//交换回来
                }
            }
        }
    }
    //交换函数
    public static void swap(char[] chars,int i,int j){
        char temp=chars[i];
        chars[i]=chars[j];
        chars[j]=temp;
    }

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(true){
            String str=scanner.nextLine();
            ArrayList<String> result=new ArrayList<String>();
            result=Permutation(str);
            System.out.println(result);
        }

    }
}

案例测试

a
[a]
ab
[ab, ba]
abc
[abc, acb, bac, bca, cab, cba]
abcd
[abcd, abdc, acbd, acdb, adbc, adcb, bacd, badc, bcad, bcda, bdac, bdca, cabd, cadb, cbad, cbda, cdab, cdba, dabc, dacb, dbac, dbca, dcab, dcba]

方法2：

public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    int[][] index=new int[6][2];
    List<Integer> list=new ArrayList<>();
    int [] test={1,2,3,4,5,21};
    while (scanner.hasNext()){
        for (int i = 0; i <6 ; i++) {
            int num =scanner.nextInt();
            //int num=test[i];
            index[i]=getindex(num);
        }
        boolean flag=true;
        first:for (int i = 0; i <5 ; i++) {
            for (int j = i; j <6 ; j++) {
                int axis=index[i][0]-index[j][0];
                int vertical=index[i][1]-index[j][1];
                if ((Math.abs(axis)==0 && Math.abs(vertical)>1)||(Math.abs(axis)>1 && Math.abs(vertical)==0)){
                    flag=false;
                    break first;
                }
            }
        }
        list.add(flag==true?1:0);
    }
    for (int i = 0; i <list.size() ; i++) {
        System.out.println(list.get(i));
    }
}
public static int[] getindex(int num){
    int []result = new int[2];
    first:for (int i=0;i<constantNum.length;i++){
        second: for (int j = 0; j <constantNum.length ; j++) {
            if (constantNum[i][j]==num){
                result[0]= i;
                result[1]= j;
                break first;
            }
        }
    }
    return result;
}