《剑指offer》字符串的排序（字典序排序与全排列问题）

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

例如：
'0' < '9' < 'a' < 'z' 是一个正确的字典序排列

1.递归的方法（全排列）

以一种简单的方式理解字符串的全排列：例如输入字符串为“abc”，那么它的全排列为：abc,acb,bac,bca,cba,cab。(注意这里不是字典排序啊。)
也就是最常想到的方式：将每个字符都依次的交换到第一个位置，然后（按照上面交换的方式继续）全排列它后面的字符串，直到剩余最后一个字符，这时可以得到一种排列方式。更直观的表达如下图所示：

注意一个问题就是：如果字符串里有重复的字符，那么只按照上述方法来计算的化将出现重复的排列情况

由于全排列就是从第一个数字起，每个数分别与它后面的数字交换，我们先尝试加个这样的判断——如果一个数与后面的数字相同那么这两个数就不交换 了。例如abb，第一个数与后面两个数交换得bab，bba。然后abb中第二个数和第三个数相同，就不用交换了。但是对bab，第二个数和第三个数不 同，则需要交换，得到bba。由于这里的bba和开始第一个数与第三个数交换的结果相同了，因此这个方法不行。
换种思维，对abb，第一个数a与第二个数b交换得到bab，然后考虑第一个数与第三个数交换，此时由于第三个数等于第二个数，所以第一个数就不再用与第三个数交换了。再考虑bab，它的第二个数与第三个数交换可以解决bba。此时全排列生成完毕！

以上避免重复的方式，换一种表达方式为：例如字符串“abcdefdghi”处理到了后面这个d字符，如果不加判断的直接把“d”交换到第一位，将导致重复，因为前面已经有一个“d”做过这样的操作了。
也就是在交换前，先看看字符串中此字符（d）之前是否存在与之相同的字符，如果有就不交换它，继续操作下一个字符。

class Solution {
public:
    int is_swap(string &str,int begin,int k) // 用于判断此字符前，还有没有与之相同的字符。
    {
        int flag=1;
        for(int i=begin;i<k;i++)     //一定注意变量的生命周期！！！ for(int i=begin，flag=1;i<k;i++) 如果flag是在for里
                                    //定义的那么退出for循环时，flag会自动变成0@！！！！！！
        {
            if(str[i]==str[k])
            {
                flag=0;
                break;
            }
        }
        return flag;
    }
    void swap(string &str,int i,int j)
    {
        char temp=str[i];
        str[i]=str[j];
        str[j]=temp;
    }
   void Permu_helper(string &str ,int begin,int end)  //注意函数没有返回的话，直接操作数组的话，要取地址或者指针来
       //保持函数调用后的变化
   {
       if(begin==str.size()-1)
       {
           result.push_back(str);
           return;
       }
       for(int i=begin;i<=end;i++)
       {
       if(is_swap(str,begin,i))
       {
           swap(str,begin,i);
           Permu_helper(str,begin+1,end);
           swap(str,i,begin);  //在上一种交换后，将字符串恢复到上一步的状态。 可尝试去掉复位，看看情况。
       } 
       }
   }
    vector<string> result;
    vector<string> Permutation(string str) {
        
        if(!str.empty())   //注意一定要处理空字符串的情况！！！鲁棒性！ 否则如果输入异常，程序会直接崩溃的！！！
        {
            Permu_helper(str,0,str.size()-1);
        }
        sort(result.begin(),result.end());  //注意这里要就行sort，获得字典序排序的字符串。
        return result;
    }
};

2.（非递归）字典序排列

“123”的全排列的字典序排列为：123,132,213,231,312,321

一个全排列可看做一个字符串，字符串可有前缀、后缀。
　　生成给定全排列的下一个排列.所谓一个的下一个就是这一个与下一个之间没有其他的。这就要求这一个与下一个有尽可能长的共同前缀，也即变化限制在尽可能短的后缀上。

[例]839647521是1–9的排列。1—9的排列最前面的是123456789，最后面的987654321，从右向左扫描若都是增的，就到了987654321，也就没有下一个了。否则找出第一次出现下降的位置。

【例】 一般而言，设P是[1,n]的一个全排列。
　　　　　　P=P1P2…Pn=P1P2…Pj-1PjPj+1…Pk-1PkPk+1…Pn
　　　　find:　　j=max{i|Pi<Pi+1}
　　　　　　　　　k=max{i|Pi>Pj}
　　　　　　1，  对换Pj，Pk，
　　　　　　2，  将Pj+1…Pk-1PjPk+1…Pn翻转
          P’= P1P2…Pj-1PkPn…Pk+1PjPk-1…Pj+1即P的下一个

具体的例子如下：

【例】 如何得到346987521的下一个
  1，从尾部往前找第一个P(i-1) < P(i)的位置
          3 4 6 <- 9 <- 8 <- 7 <- 5 <- 2 <- 1
      最终找到6是第一个变小的数字，记录下6的位置i-1
  2，从i位置往后找到最后一个大于6的数
          3 4 6 -> 9 -> 8 -> 7 5 2 1
      最终找到7的位置，记录位置为m
  3，交换位置i-1和m的值
          3 4 7 9 8 6 5 2 1
  4，倒序i位置后的所有数据
          3 4 7 1 2 5 6 8 9
  则347125689为346987521的下一个排列

        private static void PermutationList()
        {
            int fromIndex, endIndex, changeIndex;
            Sort(0, length - 1);
            do
            {
                // 输出一种全排列
                Output();
                fromIndex = endIndex = length - 1;
                // 向前查找第一个变小的元素
                while (fromIndex > 0 && words[fromIndex] < words[fromIndex - 1]) --fromIndex;
                changeIndex = fromIndex;
                if (fromIndex == 0) break;
                // 向后查找最后一个大于words[fromIndex-1]的元素
                while (changeIndex + 1 < length && words[changeIndex + 1] > words[fromIndex - 1]) ++changeIndex;
                Swap(fromIndex - 1, changeIndex);   // 交换两个值
                InvertArray(fromIndex, endIndex);   // 对后面的所有值进行反向处理
            } while (true);
        }

本题算法：

class Solution {
public:
    void swap(string &str,int i,int j)
    {
        char temp=str[i];
        str[i]=str[j];
        str[j]=temp;
    }
    void reverse(string & str,int k){   //这里交换的话注意界限。
        if(str.size()==0|| str.size()-1<=k)
            return;
        int len = str.size();
        for(int i=0;i<(len-k)/2;i++){
            int m = k+i;
            int n = len-1-i;
            if(m<=n){
                swap(str,m,n);
            }
        }
    }
    vector <string> result;
    vector<string> Permutation(string str) {
        int Fromindex,Endindex,Changeindex;
        //Fromindex=Changeindex=str.size()-1;
        if(str.size()==0)   //一定要对空的字符串情况设置返回条件！！！！！要不总报内存错误。
        {
            return result;
        }
        sort(str.begin(),str.end());
        result.push_back(str);
        while(true)
        {
            Fromindex=Changeindex=str.size()-1; //注意要每次从末尾开始找！
            while(Fromindex>=1&&str[Fromindex]<=str[Fromindex-1]) Fromindex--;  //从末尾找第一个不增的位置。
            Changeindex=Fromindex;
            if(Fromindex==0) break;
            while(Changeindex<=str.size()-1&&str[Changeindex]>str[Fromindex-1]) Changeindex++;
            swap(str,Fromindex-1,Changeindex-1);
            reverse(str,Fromindex);
            result.push_back(str);
        }
        return result;

    }
};

[参考文章]
1.https://www.cnblogs.com/pmars/archive/2013/12/04/3458289.html
2.https://www.cnblogs.com/cxjchen/p/3932949.html