题目：

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

输入描述:

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

分析：

可以采用递归和非递归两种方法实现。

递归方法使用交换的的思路，我们可以将字符串看成两部分，第一个字符和后面的字串，将第一个字符和后面的每一元素互换，这样就会产生新的排列，然后再递归执行后面的字串，具体流程如图：

 

 

 出自：https://blog.csdn.net/zxzxzx0119/article/details/81452269

第二种方法可以先取一个元素到结果集，然后遍历字串剩余的元素将每一个元素插入到结果集中字符串的每一个位置，删掉取出的结果，再讲新结果存进结果集用{a，b，c}举例。

结果集中是{a}

取结果集字符串{a}，并在结果集中删掉{a}，将剩余元素b插入串{a}的每一个位置得到{b，a}，{a，b}。

取{b，a}，结果集还剩{a，b}

将c插入{b，a}得到{c，b，a}，{b，c，a}，{b，a，c}，将三个结果添加进结果集，此时{a，b}，{c，b，a}，{b，c，a}，{b，a，c}

再取出{a，b}将c插入得，{c，a，b}，{a，c，b}，{a，b，c}，添加进结果集，此时{c，b，a}，{b，c，a}，{b，a，c}，{c，a，b}，{a，c，b}，{a，b，c}

小技巧就是每次从结果集的后面取出元素，在前面插入新的结果。

不过这道题要求是有重复元素的，可以使用set来去重，不过牛客网的判题很迷，顺序不同也会判错。可以排个序再输出。

程序：

C++

class Solution {
public:
    vector<string> Permutation(string str) {
        if(str.size() == 0)
            return res;
        helper(str, 0);
        for(auto i:tempRes)
            res.push_back(i);
        return res;
    }
    void helper(string str, int index){
        if(index == str.size()-1)
            //res.push_back(str);
            tempRes.insert(str);
        for(int i = index; i < str.size(); ++i){
            swap(str[index], str[i]);
            helper(str, index+1);
        }
    }
    vector<string> res;
    set<string> tempRes;
};
class Solution {
public:
    vector<string> Permutation(string str) {
        if(str.size() == 0)
            return res;
        res.push_back(str.substr(0, 1));
        strSet.insert(str.substr(0, 1));
        for(int i = 1; i < str.size(); ++i){
            int m = res.size();
            for(int j = 0; j < m; ++j){
                string tempStr = res.back();
                res.pop_back();
                for(int k = 0; k <= tempStr.size(); ++k){
                    string ttempStr = tempStr;
                    ttempStr.insert(k, str.substr(i,1));
                    set<string>::iterator iter;
                    if((iter = strSet.find(ttempStr)) == strSet.end()){
                        res.insert(res.begin(), ttempStr);
                        strSet.insert(ttempStr);
                    }
                }
            }
        }
        sort(res.begin(), res.end());
        return res;
    }
private:
    set<string> strSet;
    vector<string> res;
};

Java

import java.util.ArrayList;
import java.util.Collections;
//import java.util.HashSet;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        if(str.length() == 0)
            return res;
        StringBuilder s = new StringBuilder(str);
        Helper(s, 0);
        Collections.sort(res);
        return res;
    }
    public void Helper(StringBuilder s, int index){
        if(index == s.length()-1)
            res.add(s.toString());
        for(int i = index; i < s.length(); ++i){
            if(s.charAt(index) != s.charAt(i) || index == i){
                Swap(s, index, i);
                Helper(s, index+1);
                Swap(s, index, i);
            }
        }
    }
    public static void Swap(StringBuilder s, int i, int j) {
        char temp = s.charAt(i);
        s.setCharAt(i, s.charAt(j));
        s.setCharAt(j, temp);
    }
    private ArrayList<String> res = new ArrayList<>();
    //private HashSet<String> set = new HashSet<>();
}

 

版权声明：本文为silentteller原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/silentteller/p/11953921.html