字符串的排列

题目描述
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

//第一种
class Solution {
public:
    vector<string> Permutation(string str) {
        vector<string> answer;
        if(str.empty())
            return answer;        
        sort(str.begin(),str.end());
        do{
            answer.push_back(str);
        }
        while(next_permutation(str.begin(),str.end()));
        return answer;
    }
};
/*
其中next_permutation的原理：
http://leonard1853.iteye.com/blog/1450085
百度搜索：全排列。应该可以理解下面的代码了。

template<class BidirectionalIterator>
bool next_permutation(
      BidirectionalIterator first, 
      BidirectionalIterator last
)
{
    if(first == last)
        return false; //空序列

    BidirectionalIterator i = first;
    ++i;
    if(i == last)
        return false;  //一个元素，没有下一个序列了

    i = last;
    --i;

    for(;;) {
        BidirectionalIterator ii = i;
        --i;
        if(*i < *ii) {
            BidirectionalIterator j = lase;
            while(!(*i < *--j));

            iter_swap(i, j);
            reverse(ii, last);
            return true;
        }

        if(i == first) {
            reverse(first, last);  //全逆向，即为最小字典序列，如cba变为abc
            return false;
        }
    }
}
*/

//第二种：用递归实现字典序法，好像还有一种字典序法不用递归来实现，不确定。
class Solution {
    int u[10]={0};
    vector<string> a;
public:
    vector<string> Permutation(string str) {
        string tmp;
        if(str.size()==0)
            return a;
        Permu(str,tmp);
        sort(a.begin(),a.end());
        a.erase(unique(a.begin(),a.end()),a.end());
        return a;
    }
    void Permu(string str,string tmp){
        if(str.size()==tmp.size())
            return a.push_back(tmp);
        for(int i=0;i<str.size();++i){
            if(u[i]==0){
                u[i]=1;
                tmp+=str[i];
                Permu(str,tmp);
                tmp=tmp.substr(0,tmp.size()-1);
                u[i]=0;
            }
        }
    }
    /*
    Permu函数也可以这么做，对if中的临时数据tmp1操作，而不是直接对tmp操作，可以不用执行删除末尾字符。
    void Permu(string str,string tmp){
        if(str.size()==tmp.size())
            return a.push_back(tmp);
        for(int i=0;i<str.size();++i){
            if(u[i]==0){
                string tmp1=tmp;
                u[i]=1;
                tmp1+=str[i];
                Permu(str,tmp1);
                u[i]=0;
            }
        }
    }
    */
};

/*
第三种方法：
虽然是递归，但第二种字典序法有区别。
*/
class Solution {
public:
    vector<string> result;
    vector<string> Permutation(string str) {
        if(str.length()==0){
            return result;
        }
        Permutation1(str,0);
        sort(result.begin(),result.end());
        return result;
    }
    void Permutation1(string str,int begin){
        if(begin == str.length()){
            result.push_back(str);
            return ;
        }
            for(int i = begin; str[i]!='\0';i++){

                if(i!=begin&&str[begin]==str[i])
                    continue;
                swap(str[begin],str[i]);
                Permutation1(str,begin+1);
                swap(str[begin],str[i]);
            }

    }
};