全排列算法汇总（C++版）

全排列算法相信大家都比较熟悉了，这里只是对各种全排列算法进行一个汇总，让大家有个较全面的了解。由于有些版本被转载太多次了，故没法找到原创作者，这里就不特别注明了。

递归版本：

这是最通俗易懂的一个版本，不过网上流传的代码中第18行没有注释掉，我看了一下运行结果是一样的，只是顺序不一样。网上流传的版本在输出顺序上不是以递增的顺序出现，因为它每次交换过后又交换回来了。而注释掉的版本的输出顺序则是递增的顺序。
以下是代码：

1. /**
2. *   Permutation helper.
3. *   @param  str     original strings
4. *   @return         all the permutations
5. */
6. void Permutation_Generator(string str, int m, int n, vector<string> &result)
7. {
8.     if (m > n)
9.     {
10.         result.push_back(str);
11.     }
12.     else
13.     {
14.         for (int i = m; i <= n; ++i)
15.         {
16.             Swap<char>(str[m], str[i]);
17.             Permutation_Generator(str, m + 1, n, result);
18.             //Swap<char>(str[m], str[i]);
19.         }
20.     }
21. }
22. 
    
23. /**
24. *   Get the permutation of the strings.
25. *   @param  str     original strings
26. *   @return         all the permutations
27. */
28. vector<string> Permutation(string str)
29. {
30.     vector<string> result;
31.     Permutation_Generator(str, 0, str.size() - 1, result);
32.     return result;
33. }

非递归版本：
这个不是从网上看到的，是根据Kenneth H.Rosen的《离散数学及其应用的思路》写出来的。写得比较粗糙，还请见谅。

这个方法的主要思路是，根据当前序列确定下一个序列，直到某一条件被满足则所有序列遍历完成。

设一个序列为 {a ₁,a ₂, ... a _n}。我们的目的是要找到下一个排列。
1.我们要找到a _j和a _j+1，使得a _j<a _j+1且a _j+1>a _j+2>...>a _n。即找到两个元素，这两个元素后面的元素呈单减。
2.从a _j+1开始，找到比a _j大的最小的数a _k，交换a _j和a _k。
3.对j位置之后的数进行升序排序，生成的序列便是下一个排列。

1. /**
2.  *  Get the permutation of the vectors.
3.  *  @param  vec     the vector that contains the elements
4.  *  @return the output of all the permutation sequence
5.  */
6. template <typename T>
7. vector<vector<T>> Permutation(vector<T> vec)
8. {
9.     vector<vector<T>> retPerm;
10.     retPerm.push_back(vec);
11.     bool ret = true;
12.     while(true == ret)
13.     {
14.         ret = Next_Permutation(vec);
15.         if (ret)
16.         {
17.             retPerm.push_back(vec);
18.         }
19.     }
21.     return retPerm;
22. }
24. /**
25.  *  Get the next permutation sequence according to the current sequence.
26.  *  @param  vec     current sequenece
27.  *  @return whether there exist next sequence
28.  */
29. template <typename T>
30. bool Next_Permutation(vector<T> &vec)
31. {
32.     int i = vec.size() - 2;
33.     //  find the position that vec[i] <= vec[i]
34.     while (i > 0 && vec[i] > vec[i + 1])
35.     {
36.         --i;
37.     }
39.     //  find the least larger element located on the right side of vec[i]
40.     int k = vec.size() - 1;
41.     int leastLarger = -1;
43.     for (int j = i; j < vec.size(); ++j)
44.     {
45.         if (vec[j] > vec[i])
46.         {
47.             leastLarger = j;
48.             break;
49.         }
50.     }
52.     if (leastLarger == -1)
53.     {
54.         return false;
55.     }
57.     while (k > i)
58.     {
59.         if ((vec[leastLarger] >= vec[k]) && (vec[k] > vec[i]))
60.         {
61.             leastLarger = k;
62.         }
63.         --k;
64.     }
66.     Swap(vec[i], vec[leastLarger]);
68.     //  sort the remain part of vector
69.     vector<T>::iterator it = vec.begin();
70.     for (int j = 0; j < i; ++j)
71.     {
72.         ++it;
73.     }
74.     ++it;
76.     sort(it, vec.end());
78.     return true;
79. }

以上便是最常用的两种方式。