字符串的排列-CSDN博客

本文链接：https://blog.csdn.net/wang11234514/article/details/29375203

题意：输入一个字符串，输出该字符串中字符的所有排列，比如输入abc，则输入abc、acb、bac、bca、cab、cba

解题思路：将字符串看作两部分：(1)第一个字符；(2)剩余的字符。由此对字符串的排列分两步处理：(1)求得所有可能出现在第一个位置上的字符（通过将第一个字符与后面的所有字符逐一交换来实现）；(2)将剩余的字符当作一个新的字符串，按上述方式递归处理

递归的代码如下：

void Permutation(string &str, string::size_type begPos)
{
    if(str.size() == begPos)
    {   
        cout << str << endl;
    }   
    else
    {   
        //sst必须从begPos开始，如果从begPos+1开始，就会漏掉以begPos开始的结果
        for(string::size_type sst = begPos; sst < str.size(); sst++)
        {     
                Swap(str[sst], str[begPos]);

                Permutation(str, begPos + 1); 

                Swap(str[sst], str[begPos]);  
        }   
    }   
}

当字符串中存在重复的字符时，上述方法无法去除重复的输出，对其改进为在求第一个位置可能出现的所有字符时，如果某个字符在前面的字符中已经出现，则就不在考虑( 比如在需要将begin，last位置上的数互换时，没有去重的方案就是直接互换，去重的方案会在[begin，last)的区间内判断last位置上的数是否存在，如果存在则跳过，处理下一个字符；不存在就处理它)

代码如下：

bool IsExist(const string &str, string::size_type begin, string::size_type end)
{
    for(string::size_type sst = begin; sst < end; sst++)
    {
        if(str[sst] == str[end])
            return false;
    }   
    return true;
}

void Permutation(string &str, string::size_type begPos)
{
    if(str.size() == begPos)
    {   
        cout << str << endl;
    }   
    else
    {   
        //sst必须从begPos开始，如果从begPos+1开始，就会漏掉以begPos开始的结果
        for(string::size_type sst = begPos; sst < str.size(); sst++)
        {   
            if(IsExist(str, begPos, sst))
            {   
                Swap(str[sst], str[begPos]);

                Permutation(str, begPos + 1); 

                Swap(str[sst], str[begPos]);
            }
        }
    }
}

上面实现的是递归的方案，非递归该如何实现呢？

STL中提供了两个计算排列组合的算法，next_permutation函数和prev_permutation函数

next_permutation()会取得[first，last)返回内的下一个排列组合(当前排列的直接后继)。如果没有下一个排列组合(当前组合已最大)，则返回false，否则返回true

prev_permutation()会取得[first，last)返回内的上一个排列组合(当前排列的直接前序)。如果没有上一个排列组合(当前组合已最小)，则返回false，否则返回true

算法说明：

next_permutation:

从最尾端开始往前寻找两个相邻元素，令第一个为*i，第二个为*ii，满足*i < *ii。
如果找到了这样的一组相邻元素，在从最尾端开始往前寻找第一个大于*i的元素，令其为*j
将*i与*j对调，再将ii之后的所有元素都颠倒排序，所得的即为“下一个排列“

证明：

假设要处理的序列是a b c d e，并由第一步得到*i = a，*ii = b，即a < b。这里还有一个潜在的条件即b > c > d > e，bcde已是一个最大的排列，那么abcde则是一个第一位固定为a时的最大排列
根据排列的性质，下一个排列应该是这样的一个字符串，第一位是bacd中第一个比a大的字符，剩下的字符则按从小到大排列，得到的就是下一个排列
算法的第二步就是在寻找第一个比a大的字符，假设为d，则有e < a < d，即e < a < d < c < b
算法三步将*i与*j对调用的字符串为dbcae，由前一步可以知道bcae是一个最大的排列，将其颠倒排序之后，就为一个最小的排列了
证明完毕

template <class Iterator>
bool NextPermutation(Iterator first, Iterator last)
{
    if(first == last || (first + 1) == last)
    {
        return false;
    }
    
    Iterator i = last - 1, ii;
    for(;;)
    {
        ii = i;
        i--;

        //从尾部开始寻找第一组相邻的两个数满足前一个数<后一个数
        if(*i < *ii)      
        {
            //从尾部开始寻找第一个大于*i的元素
            Iterator j = last;
            while(*(--j) <= *i);
            
            iter_swap(i, j);
            reverse(ii, last);
            return true;
        }
        if(i == first)       //没有下一个排列了，回到初始状态
        {
            reverse(first, last);
            return false;
        }
    }
}

prev_permutation：

从最尾端开始往前寻找两个相邻元素，令第一个为*i，第二个为*ii，满足*i > *ii
如果找到了这样的一组相邻元素，在从最尾端开始往前寻找第一个小于*i的元素，令其为*j
将*i与*j对调，再将ii之后的所有元素都颠倒排序，所得的即为“前一个”排列

算法的证明跟next_permutation是类似的，这里不在说明

template <class Iterator>
bool PrevPermutation(Iterator first, Iterator last)
{
    if(first == last || (first + 1) == last)
    {
        return false;
    }


    Iterator i = last - 1, ii;
    for(;;)
    {
        ii = i;
        i--;


        if(*i > *ii)
        {
            Iterator j = last;
            while(*i <= *(--j));


            iter_swap(i, j);
            reverse(ii, last);
            return true;
        }
        if(i == first)
        {
            reverse(first, last);
            return false;
        }
    }
}