打印全排列是个有点挑战的编程问题。STL提供了stl::next_permutation完美的解决了这个问题。
但是，如果不看stl::next_permutation，尝试自己解决，怎么做？
很自然地，使用递归的办法：
1. 单个元素的排列只有1个。
2. 多个元素的排列可以转化为：
以每个元素为排列的首个元素，加上其他元素的排列。
有了思路，就可以编码了。
第一个版本：
void printAllPermutations(const std::string& prefix, int set[], int n)
{
using namespace std;
char buffer[12];
for (int i=0; i<n; ++i)
{
string tmp_prefix(prefix);
int ei = set[i];
_itoa_s(ei, buffer, 12, 10);
tmp_prefix += buffer;
if (n == 1)
{
cout << tmp_prefix.c_str() << endl;
}
else
{
tmp_prefix += " " ;
// shift set[0,i) to right by 1
for (int j=i-1; j>=0; --j)
{
set[j+1] = set[j];
}
printAllPermutations(tmp_prefix, set+1, n-1);
// shift set[0,i) to left by 1
for (int j=0; j<i; ++j)
{
set[j] = set[j+1];
}
set[i] = ei;
}
}
}
测试：int myints[] = {1,2,3,4};
printAllPermutations( "" , myints, 4);
通过。
这种方法的缺点是产生了大量的string对象。怎么避免呢？
第二个版本：
void printAllPermutations2(int set[], int n, int from)
{
using namespace std;
for (int i=from; i<n; ++i)
{
int ei = set[i];
if (from == n-1)
{
// it is possible use callback here instead of printing a permutation
for (int j=0; j<n; ++j)
{
cout << set[j] << ‘ ‘ ;
}
cout << endl;
}
else
{
// shift set[from,i) to right by 1
for (int j=i-1; j>=from; --j)
{
set[j+1] = set[j];
}
set[from] = ei;
printAllPermutations2(set, n, from+1);
// shift set[from,i) to left by 1
for (int j=from; j<i; ++j)
{
set[j] = set[j+1];
}
set[i] = ei;
}
}
}
测试：
int myints[] = {1,2,3,4};
printAllPermutations2(myints, 4, 0);
通过。
第二个版本相比第一个版本的另一个改进是可以很容易地改变成回调函数的形式，扩展函数的用途，而不仅仅是打印排列。
似乎很不错了。
但是和stl::next_permutation相比，以上的方案就太逊了。
1. stl::next_permutation支持部分排列，而不必是全排列。你可以从任何一个排列开始，可以随时退出next_permutation循环。
2. stl::next_permutation支持多重集的排列。例如：
int myints[] = {1,2,2,2};
do {
std::cout << myints[0] << ‘ ‘ << myints[1] << ‘ ‘ << myints[2] << ‘ ‘ << myints[3] << ‘\n‘;
} while ( std::next_permutation(myints,myints+4) );
1 2 2 2
2 1 2 2
2 2 1 2
2 2 2 1
没有重复的排列。
stl::next_permutation这么强大，很值得看看它究竟是怎么实现的。
// TEMPLATE FUNCTION next_permutation
template < class _BidIt> inline
bool _Next_permutation(_BidIt _First, _BidIt _Last)
{ // permute and test for pure ascending, using operator<
_DEBUG_RANGE(_First, _Last);
_BidIt _Next = _Last;
if (_First == _Last || _First == --_Next)
return (false );
for (; ; )
{ // find rightmost element smaller than successor
_BidIt _Next1 = _Next;
if (_DEBUG_LT(*--_Next, *_Next1))
{ // swap with rightmost element that‘s smaller, flip suffix
_BidIt _Mid = _Last;
for (; !_DEBUG_LT(*_Next, *--_Mid); )
;
std::iter_swap(_Next, _Mid);
std::reverse(_Next1, _Last);
return (true );
}
if (_Next == _First)
{ // pure descending, flip all
std::reverse(_First, _Last);
return (false );
}
}
}
template < class _BidIt> inline
bool next_permutation(_BidIt _First, _BidIt _Last)
{ // permute and test for pure ascending, using operator<
return _Next_permutation(_CHECKED_BASE(_First), _CHECKED_BASE(_Last));
}
代码不长，但需要研究才能理解。很多算法都是这样的。
这个算法可以概括为：
如果只有零个或一个元素，返回false，表示回到全排列的起点。
否则，从右边开始，找到第一个不是递减的元素，即E(i) < E(i+1)，从E(i+1)一直到E(n)都是不增的。
如果找到，从右边开始，找到大于E(i)的那个元素E(x)【一定会找到】，交换E(i)和E(x)，然后把E[i+1, n]范围内的元素反转。返回true。
如果找不到，把整个范围内的元素反转，返回false，表示回到全排列的起点。
为什么这个算法可行呢？看下面1 2 3 4的全排列。
可以很容易地看到，如果把每个排列看成一个数，那么下一个排列大于上一个排列。
算法的关键：从E(i+1)一直到E(n)都是不增的。
这个特性说明，这一范围的元素的排列已经达到最大值，下一个排列必须是找到这一范围内大于这一范围的前一元素的元素，交换这两个元素，交换后E[i+1, n]仍为不增排列【最大排列】，反转之后，变成不减排列【最小排列】。这样处理后得到的排列正好是下一个排列。
这样就可以理解这个算法了。
1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
1 4 2 3
1 4 3 2
2 1 3 4
2 1 4 3
2 3 1 4
2 3 4 1
2 4 1 3
2 4 3 1
3 1 2 4
3 1 4 2
3 2 1 4
3 2 4 1
3 4 1 2
3 4 2 1
4 1 2 3
4 1 3 2
4 2 1 3
4 2 3 1
4 3 1 2
4 3 2 1
