[收集]字符串的全排列和组合

今天学习了一下何海涛博客中的第28题，字符串的排列问题，实际上指的是字符串的全排列问题（排列和全排列还是有区别的吧）。思考并研究了这题之后就考虑了一下不同条件下其他类似的题的解法的编写，两部分来自于何海涛，其他来自于网络，此处做搬运和收集工作。分别从四个方面考虑：一、字符串的全排列
（1）若不考虑字符串中有重复字符（即假设字符串中无重复字符）
（2）若考虑字符串中有重复字符（即假设字符串中有重复字符）

二、字符串的组合
（1）若不考虑字符串中有重复字符（即假设字符串中无重复字符）
（2）若考虑字符串中有重复字符（即假设字符串中有重复字符）


一、字符串的全排列
（1）若不考虑字符串中有重复字符（即假设字符串中无重复字符）
此时“abc”的全排列为：abc、acb、bac、bca、cab和cba。

      我们以三个字符abc为例来分析一下求字符串排列的过程。首先我们固定第一个字符a，求后面两个字符bc的排列。当两个字符bc的排列求好之后，我们把第一个字符a和后面的b交换，得到bac，接着我们固定第一个字符b，求后面两个字符ac的排列。现在是把c放到第一位置的时候了。记住前面我们已经把原先的第一个字符a和后面的b做了交换，为了保证这次c仍然是和原先处在第一位置的a交换，我们在拿c和第一个字符交换之前，先要把b和a交换回来。在交换b和a之后，再拿c和处在第一位置的a进行交换，得到cba。我们再次固定第一个字符c，求后面两个字符b、a的排列。既然我们已经知道怎么求三个字符的排列，那么固定第一个字符之后求后面两个字符的排列，就是典型的递归思路了。

[cpp]  view plain copy

1. void Permutation(char* pSrc,  char* pBegin)  
2. {  
3.     if (!pSrc || !pBegin)  
4.     {  
5.         return;  
6.     }  
7.   
8.     if (*pBegin == '\0')  
9.     {  
10.         printf("%s\n", pSrc);  
11.     }  
12.     else  
13.     {  
14.         for (char* pCh=pBegin; *pCh!='\0'; ++pCh)  
15.         {  
16.             char temp = *pBegin;  
17.             *pBegin = *pCh;  
18.             *pCh = temp;  
19.   
20.             Permutation(pSrc, pBegin+1);  
21.   
22.             temp = *pBegin;  
23.             *pBegin = *pCh;  
24.             *pCh = temp;  
25.         }  
26.     }  
27. }  
28.   
29.   
30. int main()  
31. {  
32.     char pSrc[] = "abc";  
33.   
34.     Permutation(pSrc, pSrc);  
35.   
36.     return 0;  
37. }  

运行结果是：

（2）若考虑字符串中有重复字符（即假设字符串中有重复字符）
上述思路非常好，但是若存在重复字符，则就不正确了，比如对于上述程序，输入“aabc”，则输出：


      就会出现重复的结果。我本来思考着如果在与*pBegin交换时加一个条件语句判断是否相等，若与*pBegin相等就不交换，若不相等才交换，用“aabc”测试时结果确实正确了。但是实际上是错误的，比如用“abbc”测试时就不正确了。
      我也是看到了一个网友的方法才发现我上述考虑的方法是错误的，他的方法是判断当前*pCh的字符（即准备与*pBegin交换的字符）在前面的子字符串中是否出现过了，若出现了，就不交换，若没出现就交换。代码如下：

[cpp]  view plain copy

1. void Permutation(char* pSrc,  char* pBegin)  
2. {  
3.     if (!pSrc || !pBegin)  
4.     {  
5.         return;  
6.     }  
7.   
8.     if (*pBegin == '\0')  
9.     {  
10.         printf("%s\n", pSrc);  
11.     }  
12.     else  
13.     {  
14.         for (char* pCh=pBegin; *pCh!='\0'; ++pCh)  
15.         {  
16.             if(strchr(pBegin, *pCh) == pCh)  
17.             {  
18.                 char temp = *pBegin;  
19.                 *pBegin = *pCh;  
20.                 *pCh = temp;  
21.   
22.                 Permutation(pSrc, pBegin+1);  
23.   
24.                 temp = *pBegin;  
25.                 *pBegin = *pCh;  
26.                 *pCh = temp;  
27.             }  
28.         }  
29.     }  
30. }  
31.   
32.   
33. int main()  
34. {  
35.     char pSrc[] = "abbc";  
36.   
37.     Permutation(pSrc, pSrc);  
38.   
39.     return 0;  
40. }  

运行结果是：



二、字符串的组合
（1）若不考虑字符串中有重复字符（即假设字符串中无重复字符）
      输入一个字符串，输出该字符串中字符的所有组合。举个例子，如果输入" abc"，它的组合有a、b、c、ab、ac、bc、abc。

      本题也可以用递归的思路来求字符串的组合。
      假设我们想在长度为n的字符串中求m个字符的组合。我们先从头扫描字符串的第一个字符。针对第一个字符，我们有两种选择：一是把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选取m-1个字符；而是不把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选择m个字符。这两种选择都很容易用递归实现。下面是这种思路的参考代码：

[cpp]  view plain copy

1. void Combination(char* str, int number, vector<char>& result)  
2. {  
3.     if (str==NULL)  
4.     {  
5.         return;  
6.     }  
7.   
8.     if (number==0)  
9.     {  
10.         for (vector<char>::iterator ite = result.begin(); ite!=result.end(); ++ite)  
11.         {  
12.             cout<<*ite;  
13.         }  
14.         cout<<endl;  
15.         return;  
16.     }  
17.   
18.     if (*str == '\0')  
19.     {  
20.         return;   
21.     }  
22.       
23.     else  
24.     {  
25.         Combination(str+1, number, result);  
26.   
27.         result.push_back(*str);  
28.         Combination(str+1, number-1, result);  
29.         result.pop_back();  
30.     }  
31.   
32. }  
33.   
34.   
35. int main()  
36. {  
37.     char pSrc[] = "abc";  
38.   
39.     vector<char> result;  
40.     for (int i=1; i<=strlen(pSrc); ++i)  
41.     {  
42.         Combination(pSrc, i, result);  
43.     }  
44.       
45.     return 0;  
46. }  

      运行结果是：

也可以去掉上述中的循环：

[cpp]  view plain copy

1. void Combination(char* str, int number, vector<char>& result)  
2. {  
3.     if(*str == '\0')  
4.     {  
5.           
6.         for(vector<char>::iterator ite = result.begin();  
7.             ite != result.end();   
8.             ++ite)  
9.         {  
10.             cout<<*ite;  
11.         }  
12.         cout<<endl;  
13.   
14.         return;  
15.     }  
16.   
17.     result.push_back(*str);  
18.     Combination(str + 1, number - 1, result);  
19.     result.pop_back();  
20.   
21.     Combination(str + 1, number-1, result);  
22. }  
23.   
24. int main()  
25. {  
26.     char pSrc[] = "abc";  
27.   
28.     vector<char> result;  
29.     Combination(pSrc, strlen(pSrc), result);  
30.   
31.     return 0;  
32. }  

        另外，看到一个网友的思路： 用一个数组，模拟2进制加法器，某一个为1，则取对应的字符，若为0则不取，就能够实现字符组合。这个思路也非常好~ 不过是在字符长度不超过32的情况下。


（2）若考虑字符串中有重复字符（即假设字符串中有重复字符）
       但是上述代码在字符串中有重复字符时就出问题了，如输入”abbc“，则输出为：


就出现了重复的结果。
        我想可以先去掉字符串中所有重复的字符，比如由“abbcc”转换成“abc”，再用上述算法来做。不知道其他的更高效的算法，待续......