剑指offer-27、字符串的排列

题⽬描述

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

输⼊描述:输⼊⼀个字符串,⻓度不超过9(可能有字符重复),字符只包括⼤⼩写字⺟

思路及解答

递归回溯(使用Set去重)

看到题目,应该就知道要使⽤回溯了。

通过 ​回溯算法 ​ 生成所有排列,配合 ​剪枝条件​ 实现去重和字典序输出。关键步骤包括:

  1. 固定位置法:逐个固定每个位置的字符
  2. 交换策略:通过交换字符位置生成不同排列
  3. 去重处理:使用集合(Set)或排序后跳过重复字符来避免重复排列
  4. 字典序排序:最后对结果进行排序
java 复制代码
import java.util.ArrayList;
import java.util.Collections;

public class StringPermutation {
    public ArrayList<String> permutation(String str) {
        ArrayList<String> result = new ArrayList<>();
        if (str == null || str.length() == 0) {
            return result;
        }
        
        char[] chars = str.toCharArray();
        permute(chars, 0, result);
        Collections.sort(result); // 按字典序排序
        return result;
    }
    
    private void permute(char[] chars, int begin, ArrayList<String> result) {
        if (begin == chars.length - 1) {
            result.add(new String(chars));
            return;
        }
        
        for (int i = begin; i < chars.length; i++) {
            // 跳过重复字符,避免重复排列
            if (i != begin && chars[i] == chars[begin]) {
                continue;
            }
            
            swap(chars, begin, i);
            permute(chars, begin + 1, result);
            swap(chars, i, begin); // 回溯,恢复原始状态
        }
    }
    
    private void swap(char[] chars, int i, int j) {
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
    }
}
  • 时间复杂度:O(n*n!),n为字符串长度,n!是排列总数,每次排列需要O(n)时间
  • 空间复杂度:O(n!),需要存储所有排列结果

回溯+剪枝法(优化去重)

上面方法主要是通过Set进行去重,也可以将字符数组排序来跳过重复字符:

  1. 先排序:将字符数组排序,使相同字符相邻
  2. 剪枝策略:在递归过程中跳过相同字符的重复分支
  3. 标记数组:使用boolean数组记录已使用字符
java 复制代码
public class StringPermutation {
    public ArrayList<String> permutation(String str) {
        ArrayList<String> result = new ArrayList<>();
        if (str == null || str.length() == 0) {
            return result;
        }
        
        char[] chars = str.toCharArray();
        Arrays.sort(chars); // 先排序便于去重
        boolean[] used = new boolean[chars.length];
        backtrack(chars, used, new StringBuilder(), result);
        return result;
    }
    
    private void backtrack(char[] chars, boolean[] used, 
                         StringBuilder path, ArrayList<String> result) {
        if (path.length() == chars.length) {
            result.add(path.toString());
            return;
        }
        
        for (int i = 0; i < chars.length; i++) {
            // 剪枝条件:跳过已使用字符或相同字符的重复分支
            if (used[i] || (i > 0 && chars[i] == chars[i-1] && !used[i-1])) {
                continue;
            }
            
            used[i] = true;
            path.append(chars[i]);
            backtrack(chars, used, path, result);
            path.deleteCharAt(path.length() - 1); // 回溯
            used[i] = false;
        }
    }
}
  • 时间复杂度:O(n*n!),但剪枝减少了不必要的递归调用
  • 空间复杂度:O(n!),结果存储空间

非递归

此方法算法理解难度较大,非标准解法

用字典序生成下一个排列的算法:

  1. 初始排序:将字符数组按字典序排序
  2. 找下一个排列
    • 从后向前找到第一个升序对
    • 交换适当元素
    • 反转后缀
  3. 循环生成:直到无法生成下一个排列
java 复制代码
import java.util.ArrayList;
import java.util.Arrays;

public class StringPermutation {
    public ArrayList<String> permutation(String str) {
        ArrayList<String> result = new ArrayList<>();
        if (str == null || str.length() == 0) {
            return result;
        }
        
        char[] chars = str.toCharArray();
        Arrays.sort(chars); // 初始排序
        result.add(new String(chars));
        
        while (true) {
            int i = chars.length - 2;
            // 从后向前找第一个升序对
            while (i >= 0 && chars[i] >= chars[i + 1]) {
                i--;
            }
            if (i < 0) break; // 已是最大排列
            
            int j = chars.length - 1;
            // 找到第一个大于chars[i]的字符
            while (chars[j] <= chars[i]) {
                j--;
            }
            
            swap(chars, i, j);
            reverse(chars, i + 1, chars.length - 1);
            result.add(new String(chars));
        }
        
        return result;
    }
    
    private void swap(char[] chars, int i, int j) {
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
    }
    
    private void reverse(char[] chars, int start, int end) {
        while (start < end) {
            swap(chars, start++, end--);
        }
    }
}
  • 时间复杂度:O(n*n!),每次生成下一个排列需要O(n)时间
  • 空间复杂度:O(n!),结果存储空间
相关推荐
SimonKing4 小时前
弃用MinIO,拥抱全新一代分布式文件系统RustFS
java·后端·程序员
AAA修煤气灶刘哥5 小时前
后端人必看!配置中心这玩意儿,用 Nacos 玩明白能少熬 3 个夜
java·后端·spring cloud
七夜zippoe5 小时前
Java 技术支撑 AI 系统落地:从模型部署到安全合规的企业级解决方案(一)
java·人工智能·安全
小蒜学长5 小时前
vue飞自在酒店管理系统(代码+数据库+LW)
java·数据库·spring boot·后端
MrSYJ5 小时前
别告诉我你还不会OAuth 2.0客户端的认证:OAuth2ClientAuthenticationFilter。
java·后端·spring
北京_宏哥5 小时前
《刚刚问世》系列初窥篇-Java+Playwright自动化测试-38-屏幕截图利器-上篇(详细教程)
java·前端·面试
awei09165 小时前
SpringBoot3中使用Caffeine缓存组件
java·缓存·springboot·springboot3
xiguolangzi5 小时前
mysql业务笔记
java
杨杨杨大侠5 小时前
手搓责任链框架 3:处理器实现
java·spring·github