牛客题解 | 字符串的排列

wc529065

已于 2025-04-01 09:44:34 修改

阅读量895

点赞数 25

CC 4.0 BY-SA版权

分类专栏：牛客面试高频题单题解文章标签：算法力扣面试算法力扣

于 2025-04-01 09:44:02 首次发布

本文链接：https://blog.youkuaiyun.com/wc529065/article/details/146900014

牛客面试高频题单题解专栏收录该内容

220 篇文章

订阅专栏

题目## 题目

题目链接

题目主要信息:

给定一个长度为n的字符串，求其中所有字符的全排列
字符串中可能有重复字符，打印顺序任意
字符串中只包含大小写字母

举一反三：

学习完本题的思路你可以解决如下题目：

JZ12. 矩阵中的路径

方法：递归+回溯（推荐使用）

知识点：递归与回溯

递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。

如果是线型递归，子问题直接回到父问题不需要回溯，但是如果是树型递归，父问题有很多分支，我需要从子问题回到父问题，进入另一个子问题。因此回溯是指在递归过程中，从某一分支的子问题回到父问题进入父问题的另一子问题分支，因为有时候进入第一个子问题的时候修改过一些变量，因此回溯的时候会要求改回父问题时的样子才能进入第二子问题分支。

思路：

都是求元素的全排列，字符串与数组没有区别，一个是数字全排列，一个是字符全排列，因此大致思路与有重复项数字的全排列类似，只是这道题输出顺序没有要求。但是为了便于去掉重复情况，我们还是应该参照数组全排列，优先按照字典序排序，因为排序后重复的字符就会相邻，后续递归找起来也很方便。

使用临时变量去组装一个排列的情况：每当我们选取一个字符以后，就确定了其位置，相当于对字符串中剩下的元素进行全排列添加在该元素后面，给剩余部分进行全排列就是一个子问题，因此可以使用递归。

终止条件： 临时字符串中选取了n个元素，已经形成了一种排列情况了，可以将其加入输出数组中。
返回值： 每一层给上一层返回的就是本层级在临时字符串中添加的元素，递归到末尾的时候就能添加全部元素。
本级任务： 每一级都需要选择一个元素加入到临时字符串末尾（遍历原字符串选择）。

递归过程也需要回溯，比如说对于字符串“abbc”，如果事先在临时字符串中加入了a，后续子问题只能是"bbc"的全排列接在a后面，对于b开头的分支达不到，因此也需要回溯：将临时字符串刚刚加入的字符去掉，同时vis修改为没有加入，这样才能正常进入别的分支。

具体做法：

step 1：先对字符串按照字典序排序，获取第一个排列情况。
step 2：准备一个空串暂存递归过程中组装的排列情况。使用额外的vis数组用于记录哪些位置的字符被加入了。
step 3：每次递归从头遍历字符串，获取字符加入：首先根据vis数组，已经加入的元素不能再次加入了；同时，如果当前的元素str[i]与同一层的前一个元素str[i-1]相同且str[i-1]已经用，也不需要将其纳入。
step 4：进入下一层递归前将vis数组当前位置标记为使用过。
step 5：回溯的时候需要修改vis数组当前位置标记，同时去掉刚刚加入字符串的元素，
step 6：临时字符串长度到达原串长度就是一种排列情况。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public void recursion(ArrayList<String> res, char[] str, StringBuffer temp, boolean[] vis){
        //临时字符串满了加入输出
        if(temp.length() == str.length){ 
            res.add(new String(temp));
            return;
        }
        //遍历所有元素选取一个加入
        for(int i = 0; i < str.length; i++){ 
            //如果该元素已经被加入了则不需要再加入了
            if(vis[i]) 
                continue;
            if(i > 0 && str[i - 1] == str[i] && !vis[i - 1])
                //当前的元素str[i]与同一层的前一个元素str[i-1]相同且str[i-1]已经用过了
                continue;  
            //标记为使用过
            vis[i] = true;  
            //加入临时字符串
            temp.append(str[i]); 
            recursion(res, str, temp, vis);
            //回溯
            vis[i] = false; 
            temp.deleteCharAt(temp.length() - 1);
        }
    }
    
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> res = new ArrayList<String>();
        if(str == null || str.length() == 0) 
            return res;
        //转字符数组
        char[] charStr = str.toCharArray();
        // 按字典序排序
        Arrays.sort(charStr); 
        boolean[] vis = new boolean[str.length()];
        //标记每个位置的字符是否被使用过
        Arrays.fill(vis, false); 
        StringBuffer temp = new StringBuffer();
        //递归获取
        recursion(res, charStr, temp, vis); 
        return res;
    }
}

C++实现代码：

class Solution {
public:
    void recursion(vector<string> &res, string &str, string &temp, vector<int> &vis){
        //临时字符串满了加入输出
        if(temp.length() == str.length()){ 
            res.push_back(temp);
            return;
        }
        //遍历所有元素选取一个加入
        for(int i = 0; i < str.length(); i++){ 
            //如果该元素已经被加入了则不需要再加入了
            if(vis[i]) 
                continue;
            if(i > 0 && str[i - 1] == str[i] && !vis[i - 1])
                //当前的元素str[i]与同一层的前一个元素str[i-1]相同且str[i-1]已经用过了
                continue;
            //标记为使用过  
            vis[i] = 1;  
            //加入临时字符串
            temp.push_back(str[i]); 
            recursion(res, str, temp, vis);
            //回溯
            vis[i] = 0; 
            temp.pop_back();
        }
    }
    
    vector<string> Permutation(string str) {
        //先按字典序排序，使重复字符串相邻
        sort(str.begin(), str.end()); 
        //标记每个位置的字符是否被使用过s
        vector<int> vis(str.size(), 0); 
        vector<string> res;
        string temp;
        //递归获取
        recursion(res, str, temp, vis); 
        return res;
    }
};

Python实现代码：

class Solution:
    def recursion(self, res:List[str], string:str, temp:str, vis:List[int]):
        #临时字符串满了加入输出
        if len(temp) == len(string): 
            res.append(temp)
            return
        #遍历所有元素选取一个加入
        for i in range(len(string)): 
            #如果该元素已经被加入了则不需要再加入了
            if vis[i]==1: 
                continue
            if i > 0 and string[i - 1] == string[i] and not vis[i - 1]:
                #当前的元素str[i]与同一层的前一个元素str[i-1]相同且str[i-1]已经用过了
                continue 
            #标记为使用过
            vis[i] = 1  
            #加入临时字符串
            temp += string[i] 
            self.recursion(res, string, temp, vis)
            #回溯
            vis[i] = 0 
            temp = temp[:-1]
            
    def Permutation(self , str: str) -> List[str]:
        #先按字典序排序，使重复字符串相邻
        str ="".join((lambda x:(x.sort(),x)[1])(list(str)))
        #标记每个位置的字符是否被使用过
        vis = [0]*len(str) 
        res = []
        temp = ""
        #递归获取
        self.recursion(res, str, temp, vis) 
        return res

复杂度分析：

时间复杂度： $O (n * n!)$ ，全排列的全部情况为n!，每次递归过程都是遍历字符串查找元素，这里是 $O (n)$
空间复杂度： $O (n)$ ，递归栈的最大深度为字符串长度n，临时字符串temp的空间也为 $O (n)$ ，res属于返回必要空间

题目链接

题目主要信息：

将字符串大小写反转
将整个字符串的所有单词位置反转

举一反三：

学会了本题的思路，你将可以解决类似的字符串问题：

BM84. 最长公共前缀

BM85. 验证IP地址

方法一：双逆转（推荐使用）

思路：

将单词位置的反转，那肯定前后都是逆序，不如我们先将整个字符串反转，这样是不是单词的位置也就随之反转了。但是单词里面的成分也反转了啊，既然如此我们再将单词里面的部分反转过来就行。

具体做法：

step 1：遍历字符串，遇到小写字母，转换成大写，遇到大写字母，转换成小写，遇到空格正常不变。
step 2：第一次反转整个字符串，这样基本的单词逆序就有了，但是每个单词的字符也是逆的。
step 3：再次遍历字符串，以每个空间为界，将每个单词反转回正常。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java代码实现:

import java.util.*;
public class Solution {
    public String trans(String s, int n) {
        if(n==0) 
            return s;
        StringBuffer res=new StringBuffer();
        for(int i = 0; i < n; i++){
            //大小写转换
            if(s.charAt(i) <= 'Z' && s.charAt(i) >= 'A')   
                res.append((char)(s.charAt(i) - 'A' + 'a'));
            else if(s.charAt(i) >= 'a' && s.charAt(i) <= 'z') 
                res.append((char)(s.charAt(i) - 'a' + 'A'));
            else 
                //空格直接复制
                res.append(s.charAt(i));  
        } 
        //翻转整个字符串
        res = res.reverse();
        for (int i = 0; i < n; i++){
            int j = i;
            //以空格为界，二次翻转
            while(j < n && res.charAt(j) != ' ')  
                j++;
            String temp = res.substring(i,j);
            StringBuffer buffer = new StringBuffer(temp);
            temp = buffer.reverse().toString();
            res.replace(i,j,temp);
            i = j;
        }
        return res.toString();
    }
}

C++代码实现:

class Solution {
public:
    string trans(string s, int n) {
        if(n==0) 
            return s;
        string res;
        for(int i = 0; i < n; i++){
            //大小写转换
            if (s[i] <= 'Z' && s[i] >= 'A')   
                res += s[i] - 'A' + 'a';
            else if(s[i] >= 'a' && s[i] <= 'z') 
                res += s[i] - 'a' + 'A';
            else 
                //空格直接复制
                res+=s[i];  
        } 
        //翻转整个字符串
        reverse(res.begin(), res.end());  
        for (int i = 0; i < n; i++){
            int j = i;
            //以空格为界，二次翻转
            while(j < n && res[j] != ' ')  
                j++;
            reverse(res.begin() + i, res.begin() + j); 
            i = j;
        }
        return res;
    }
};

Python实现代码：

class Solution:
    def trans(self , s: str, n: int) -> str:
        if n==0:
            return s
        res = ""
        for i in range(n):
            #大小写转换
            if s[i] <= 'Z' and s[i] >= 'A':  
                res += chr(ord(s[i]) - ord('A') + ord('a'))
            elif s[i] >= 'a' and s[i] <= 'z':
                res += chr(ord(s[i]) - ord('a') + ord('A'))
            else :
                #空格直接复制
                res+=s[i]  
        #单词反序
        res = list(res.split(' '))[::-1]
        print(res)
        return ' '.join(res)

复杂度分析：

时间复杂度： $O (n)$ ，虽有多个循环，但是每个循环都只有一层 $O (n)$
空间复杂度： $O (n)$ ，res是存储变换的临时字符串，也可以直接用s直接变换，这样就为 $O (1)$

方法二：分割字符串+栈（扩展思路）

知识点：栈

栈是一种仅支持在表尾进行插入和删除操作的线性表，这一端被称为栈顶，另一端被称为栈底。元素入栈指的是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；元素出栈指的是从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

思路：

题目要求将单词逆序，逆序我们就可以想到先进后出的栈，单词之间分开逆序我们需要整个字符串分割。

具体做法：

step 1：遍历字符串，遇到小写字母，转换成大写，遇到大写字母，转换成小写，遇到空格正常不变。
step 2：按照空格把字符串分割成一个个单词.
step 3：遍历分割好的单词，将单词依次存入栈中。
step 4：再从栈中弹出单词，拼接成字符串。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

java代码实现:

import java.util.*;
public class Solution {
    public String trans(String s, int n) {
        if(n==0) 
            return s;
        StringBuffer res=new StringBuffer();
        for (int i = 0; i < n; i++){
            //大小写转换
            if(s.charAt(i) <= 'Z' && s.charAt(i) >= 'A')   
                res.append((char)(s.charAt(i) - 'A' + 'a'));
            else if(s.charAt(i) >= 'a' && s.charAt(i) <= 'z') 
                res.append((char)(s.charAt(i) - 'a' + 'A'));
             else 
                //空格直接复制
                res.append((char)(s.charAt(i)));  
        }
        Stack<String> temp=new Stack<String>();
        for (int i = 0; i < n; i++){
            int j = i;
            //以空格为界，分割单词
            while(j < n && res.charAt(j) != ' ')  
                j++;
            //单词进栈
            temp.push((String)(res.substring(i, j)));  
            i = j;
        }
        //排除结尾空格的特殊情况
        if(s.charAt(n - 1) == ' ')  
            res = new StringBuffer(" ");
        else
            res = new StringBuffer();
        //栈遵循先进后厨，单词顺序是反的
        while(!temp.empty()){   
            res.append(temp.peek());
            temp.pop();
            if(!temp.empty())
                res.append(" ");
        }
        return res.toString();
    }
}

C++代码实现:

class Solution {
public:
    string trans(string s, int n) {
        if(n==0) 
            return s;
        string res;
        for (int i = 0; i < n; i++){
            //大小写转换
            if(s[i] <= 'Z' && s[i] >= 'A')   
                res += s[i] - 'A' + 'a';
            else if(s[i] >= 'a' && s[i] <= 'z') 
                res += s[i] - 'a' + 'A';
            else 
                //空格直接复制
                res+=s[i];  
        }
        stack<string> temp;
        for (int i = 0; i < n; i++){
            int j = i;
            //以空格为界，分割单词
            while(j < n && res[j] != ' ')  
                j++;
            //单词进栈
            temp.push(res.substr(i, j - i));  
            i = j;
        }
        //排除结尾空格的特殊情况
        if(s[n - 1] == ' ')  
            res = " ";
        else
            res = "";
        //栈遵循先进后厨，单词顺序是反的
        while(!temp.empty()){   
            res += temp.top();
            temp.pop();
            if(!temp.empty())
                res += " ";
        }
        return res;
    }
};

Python实现代码：

class Solution:
    def trans(self , s: str, n: int) -> str:
        if n==0: 
            return s
        res = str()
        for i in range(n):
            #大小写转换
            if s[i] <= 'Z' and s[i] >= 'A':   
                res += chr(ord(s[i]) - ord('A') + ord('a'))
            elif s[i] >= 'a' and s[i] <= 'z' :
                res += chr(ord(s[i]) - ord('a') + ord('A'))
            else :
                #空格直接复制
                res+=s[i] 
        temp = list()
        i = 0
        while i < n:
            j = i
            #以空格为界，分割单词
            while j < n and res[j] != ' ': 
                j += 1
            #单词进栈
            temp.append(res[i:j])  
            i = j
            i += 1
        #排除结尾空格的特殊情况  
        if s[n - 1] == ' ':  
            res = " "
        else:
            res = ""
        #栈遵循先进后厨，单词顺序是反的
        while len(temp) != 0:   
            res += temp[-1]
            temp.pop()
            if len(temp) != 0:
                res += " "
        return res