next_permutation 实现

之前实现的permutation一直是用数组（或者vector之类）的容器，然后递归出来的。面对要求快速求出next permutation的问题束手无策，今天看了STL中next_permution的实现，自己在没有看源码写一点吧。

#include <iostream>
#include <vector>
#include <string>

/* 算法的主要思想
以数组 0 1 2 4 3 为例
1. 从最末元素开始往前查找，找到第一对元素（第一个即为i，第二记为ii),
使*i < *ii，在本例为元素对 2 4
2. 从尾部开始往前查找，找出第一个大于i元素的值，记为j，此处为3
3. 然后交换i和j的元素，再将ii后的元素（含ii）逆置，即可得next permutaioin
例子的结果为 0 1 3 2 4
*/
template <typename T>
bool next_permutation (typename std::vector<T>::iterator first, typename std::vector<T>::iterator last)
{
typename std::vector<T>::iterator i, ii, j;

// 1. find the last pair of i and ii, let *i < *ii
ii = last - 1;
if (ii == first || first == last) // only 1 element or empty, done
return false;

i = ii - 1;
for (; *i > *ii; )
{
ii = i;
if (ii == first) // the next permutaion is not exist
return false;
-- i;
}
// found the pair

// 2. find the j
for (j = last - 1; j >= i && *j < *i; --j);

// 3. swap i and j
{
T tmp = *i;
*i = *j;
*j = tmp;
}

// reverse ii - j
while(j > ii)
{
T tmp = *j;
*j = *ii;
*ii = tmp;
-- j;
++ ii;
}

return true;
}

template <typename T>
void show(const typename std::vector<T> &v)
{
for (typename std::vector<int>::const_iterator i = v.begin(); i != v.end(); ++ i)
{
std::cout << *i << " ";
}
std::cout << std::endl;
}

int main()
{
int a[] = {0, 1, 2, 4, 3};
std::vector<int> va(a, a + sizeof(a) / sizeof(a[0]));
show<int>(va);

if (next_permutation<int>(va.begin(), va.end()))
{
show<int>(va);
}

int b[] = {4, 3, 2};
std::vector<int> vb(b, b + sizeof(b)/sizeof(b[0]));
show<int>(vb);

if (next_permutation<int>(vb.begin(), vb.end()))
{
show<int>(vb);
}
else
{
std::cout << "There is no next permutation!" << std::endl;
}

return 0;
}

SGI STL源码

// next_permutation and prev_permutation, with and without an explicitly
// supplied comparison function.

template <class _BidirectionalIter>
bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
__STL_REQUIRES(_BidirectionalIter, _BidirectionalIterator);
__STL_REQUIRES(typename iterator_traits<_BidirectionalIter>::value_type,
_LessThanComparable);
if (__first == __last)
return false;
_BidirectionalIter __i = __first;
++__i;
if (__i == __last)
return false;
__i = __last;
--__i;

for(;;) {
_BidirectionalIter __ii = __i;
--__i;
if (*__i < *__ii) {
_BidirectionalIter __j = __last;
while (!(*__i < *--__j))
{}
iter_swap(__i, __j);
reverse(__ii, __last);
return true;
}
if (__i == __first) {
reverse(__first, __last);
return false;
}
}
}