next_permutation算法对区间元素进行一次组合排序，使之字典顺序大于原来的排序，有如下两个使用原形，对迭代器区间[first,last)元素序列进行组合排序。当新排序的字典顺序大于原排序时，返回true,否则返回false,利用该算法也可以进行元素排序，但是速度较慢，排序的算法时间复杂度为n！阶乘.
对应的有向后字典排序 prev_permutation算法用于选择一个字典序更小的排序。有如下两个使用原形，对迭代器区间[first,last)元素序列进行组合排序。当新排序的字典顺序大于原排序时，返回true,否则返回false,利用该算法也可以进行元素排序，但是速度较慢，排序的算法时间复杂度为n！阶乘.------（来自c++sTL开发技术引到..
----------------------( 下面是我转来的说的比较具体的STL的prev_permutation/next_permutation算法讲解)
概念
全排列的生成算法有很多种，有递归遍例，也有循环移位法等等。但C++/STL中定义的next_permutation和prev_permutation函数则是非常灵活且高效的一种方法，它被广泛的应用于为指定序列生成不同的排列。本文将详细的介绍prev_permutation函数的内部算法。
按照STL文档的描述，next_permutation函数将按字母表顺序生成给定序列的下一个较大的排列，直到整个序列为降序为止。prev_permutation函数与之相反，是生成给定序列的上一个较小的排列。二者原理相同，仅遍例顺序相反，这里仅以next_permutation为例介绍算法。
先对序列大小的比较做出定义：两个长度相同的序列，从两者的第一个元素开始向后寻找，直到出现一个不同元素（也可能就是第它们的第一个元素），该元素较大的序列为大，反之序列为小；若一直到最后一个元素都相同，那么两个序列相等。
设当前序列为pn，下一个较大的序列为pn+1，这里蕴藏的含义是再也找不到另外的序列pm，使得pn < pm < pn+1。
问题
给定任意非空序列，生成下一个较大或较小的排列。
过程
根据上述概念易知，对于一个任意序列，最小的排列是增序，最大的为减序。那么给定一个pn要如何才能生成pn+1呢？先来看下面的例子：
设3 6 4 2为pn，下一个序列pn+1应该是4 2 3 6。观察第一个序列可以发现pn中的6 4 2已经为减序，在这个子集中再也无法排出更大的序列了，因此必须移动3的位置且要找一个数来取代3的位置。在6 4 2中6和4都比3大，但6比3大的太多了，只能选4。将4和3的位置对调后形成排列4 6 3 2。注意，由于4和3大小的相邻关系，对调后产生的子集6 3 2仍保持逆序，即该子集最大的一种排列。而4是第一次移动到头一位的，需要右边的子集为最小的排列，因此直接将6 3 2倒转为2 3 6便得到了正确的一个序列pn+1。
下面归纳分析该过程。假设一个有m个元素的序列pn，其下一组较大排列为pn+1：
若pn的最右端的2个元素构成一个最小的增序子集，那么直接反转这2个元素使该子集成为减序即可得到pn+1。理由是pn和pn+1的左边m-2个元素都相等（没有对左面的元素进行操作），仅能靠最右2个元素来分出大小。而这2个元素只能出现2种排列，其中较大的一种是减序。
若pn的最右最多有s个元素构成一个减序子集，令i = m - s，则有pn(i) < pn(i+1)，其中pn(i)表示p的某个排列pn的第i个元素。因此若将pn(i)和其右边的子集s {pn(i+1), pn(i+2), ..., pn(m)}中任意一个元素调换必能得到一个较大的排列（不一定是下一个），因此必须保持pn(i)左边的元素不动，并在子集s {pn(i+1), pn(i+2), ..., pn(m)}中找到一个仅比pn(i)大的元素pn(j)，即不存在pn(k) ∈ s且pn(i) < pn(k) < pn(j)，然后将二者调换位置。现在只要使新子集{pn(i+1), pn(i+2), ..., pn(i), ...,pn(m)}成为最小排列即得到pn+1。注意到新子集仍保持减序，那么此时直接将其反转即可得到pn+1 {pn(1), pn(2), ..., pn(j), pn(m), pn(m-1), ..., pn(i), ..., pn(i+2), pn(i+1)}。
复杂度
最好的情况为pn的最右边的2个元素构成一个最小的增序子集，交换次数为1，复杂度为O(1)，最差的情况为1个元素最小，而右面的所有元素构成减序子集，这样需要先将第1个元素换到最右，然后反转右面的所有元素。交换次数为1+(n-1)/2，复杂度为O(n)。因为各种排列等可能出现，所以平均复杂度即为O(n)。
标准库全排列next_permutation()
在标准库算法中,next_permutation应用在数列操作上比较广泛.这个函数可以计算一组数据的全排列.但是怎么用,原理如何,我做了简单的剖析.
首先查看stl中相关信息.
函数原型:
template<class BidirectionalIterator>
bool next_permutation(
BidirectionalIterator _First,
BidirectionalIterator _Last
);
template<class BidirectionalIterator, class BinaryPredicate>
bool next_permutation(
BidirectionalIterator _First,
BidirectionalIterator _Last,
BinaryPredicate _Comp
);
两个重载函数,第二个带谓词参数_Comp,其中只带两个参数的版本,默认谓词函数为"小于".
返回值:bool类型
分析next_permutation函数执行过程:
假设数列 d1,d2,d3,d4……
范围由[first,last)标记，调用next_permutation使数列逐次增大，这个递增过程按照字典序。例如，在字母表中，abcd的下一单词排列为abdc，但是，有一关键点，如何确定这个下一排列为字典序中的next，而不是next->next->next……
若当前调用排列到达最大字典序，比如dcba，就返回false，同时重新设置该排列为最小字典序。
返回为true表示生成下一排列成功。下面着重分析此过程：
根据标记从后往前比较相邻两数据，若前者小于（默认为小于）后者，标志前者为X1（位置PX）表示将被替换，再次重后往前搜索第一个不小于X1的数据，标记为X2。交换X1，X2，然后把[PX+1，last)标记范围置逆。完成。
要点：为什么这样就可以保证得到的为最小递增。
从位置first开始原数列与新数列不同的数据位置是PX，并且新数据为X2。[PX+1，last)总是递减的，[first,PX)没有改变，因为X2>X1,所以不管X2后面怎样排列都比原数列大，反转[PX+1，last）使此子数列(递增)为最小。从而保证的新数列为原数列的字典序排列next。
明白了这个原理后，看下面例子：
int main(){
int a[] = {3,1,2};
do{
cout << a[0] << " " << a[1] << " " << a[2] << endl;
}
while (next_permutation(a,a+3));
return 0;
}
输出：312/321 因为原数列不是从最小字典排列开始。
所以要想得到所有全排列
int a[] = {3,1,2}; change to int a[] = {1,2,3};
另外，库中另一函数prev_permutation与next_permutation相反，由原排列得到字典序中上一次最近排列。
所以
int main(){
int a[] = {3,2,1};
do{
cout << a[0] << " " << a[1] << " " << a[2] << endl;
}
while (prev_permutation(a,a+3));
return 0;
}
才能得到123的所有排列。
---------------------------------------------------------------------------------------------------------------------------------------------
上周见到了一道题，实现可输入任意字符串，可给出其所有可能排列组合的情况。想了半天，用自己所了解的知识都是处理不了(当然长久不用，很生疏了，再加之水平本就不高)，在网上搜搜，得出了结果，贴出解决方法来，不太跟得上时代发展的同志们可以借鉴一下。 其实也并没有多难，现在C++语言中提供了现成的算法来解决排列组合问题，它们分别是next_permutation 和prev_permutation ，需要注意的是 "如果要走遍所有的排列，你必须先将元素排序"。 以下为转载： <<C++标准程序库>>这本书，在看到"变序性算法"部分的时候，发现两个函数next_permutation, prev_permutation对于我们平时处理排列组合的问题很有帮助，根据书上的介绍写了两个个测试函数:
void func1()
{
vector<int> v;
INSERT_ELEMENTS(v, 1,3);
PRINT_ELEMENTS( v, "myself: ");
while( next_permutation( v.begin(), v.end() ) )
{
PRINT_ELEMENTS( v, "");
}
}
void func2()
{
vector<int> v;
INSERT_ELEMENTS(v, 1,3);
PRINT_ELEMENTS( v, "myself: ");
sort(v.begin(), v.end(), greater<int>() ); //增加排序(降序)
while( prev_permutation( v.begin(), v.end() ) )
{
PRINT_ELEMENTS( v, "");
}
}
如果以后再遇到类似问题，我们就如此如此，不用再费脑筋，人家有现成的函数，直接拿来用就是了。
另外普及一下：
下面这段才是真真的算法,STL里面的源码
template inline
bool next_permutation(_BidIt _First, _BidIt _Last)
{ // permute and test for pure ascending, using operator<
_BidIt _Next = _Last;
if (_First == _Last || _First == --_Next)
return (false);
for (; ; )
{ // find rightmost element smaller than successor
_BidIt _Next1 = _Next;
if (*--_Next < *_Next1)
{ // swap with rightmost element that's smaller, flip suffix
_BidIt _Mid = _Last;
for (; !(*_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);
}
}
}
Ps: "STL"：Standard Template Library,标准模板库(摘录bbs.csdn.net)
这是最早由Alexander Stepanov和Meng Lee(好像是华人的名字哦）完成，于1994年提交给ANSI/ISO 标准C++委员会并通过而成为标准C++的一部分。望文生义即可知这是一个代码库标准，不是语法标准。简单地说，STL是以C++中的模板语法为基础建立起来的一套包含基础数据结构和算法的代码库。STL的特点是实现了“类型参数化”，即STL的代码中可处理任意自定义类型的对象，如果不使用模板技术的话，这是一件相当困难的事。也因为这个原因，在最新的java及C#语法中均加入了对模板语法的支持，可见其重要性。另外一个有关STL重要的话题是GP（Generic Programming),泛型。这是与面向对象相并列的另外的一个编程模型，它以模板为基础，弱化了实体类型的差异，简化了编程时问题抽象的模型，提供了更好的封装性和弹性，对于繁杂的面向对象编程毫无疑问是一种解脱，至少是精神上的。ＧＰ是最近几年软件架构的一个研究热点，但国内真正的应用似乎并不多见。
------------------上面的知识只够可以做的题目头有......暂时还没有找到...以后再加吧！！