首先，permutation指的是對元素的重排，比如a , b , c 三個元素的所有的重排為    abc, acb, bac,bca,cab,cba 總共 3!  = 6 中情況，但是如何聲稱這六種情況呢，C++標準庫定義了函式 next_permutation，來生成一組元素的所有的全排列。

首先，瞭解該函式的宣告以及實現：

函式宣告為: [摘自 www.cplusplus.com]

std::next_permutation

default (1)	template <class BidirectionalIterator> bool next_permutation (BidirectionalIterator first, BidirectionalIterator last);
custom (2)	template <class BidirectionalIterator, class Compare> bool next_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp);

此兩者在C++的標準庫中被實現為模板的形式。

引數說明：

first last   其中的迭代器  first 和 last 用來表示元素的範圍 [ first, last ) 不對稱邊界。

再來就是該迭代器的型別為雙向迭代器，那麼也就是說 隨機迭代器和雙向迭代器可以作為該函式的引數傳入。

Compare comp   是用來比較的函式，也就是說用來決定生成的重排的順序函式，預設使用的是opeartor<符號，當然你自己也可以定義自己的比較函式，作為函式指標傳入，或者是定義仿函式，傳入函式物件，

返回值：

如果在該comp函式下，下一個重拍序列存在，則返回true，走則返回false，也就是說這一次的重拍序列已經是最後一個重排序列了。

比如，如果採用的是operator<作為比較函式的話，那麼 {1，2,3}的最後一個重排就是321，第一個重排就是123，在321之後再呼叫next_premutation,返回false，但是該函式會將原來的陣列排列為 1，2,3。

副作用：

該函式會修改傳入的元素順序。

#include 
#include 

int main()
{
    int A[] = {1,3,2};
    do{
        std::cout << A[0] << " " << A[1] << " " << A[2] << std::endl;
    }while(std::next_permutation(A,A+3));
    return 0;
}

執行結果為：

可以看出，該函式會自動在當前的元素的順序基礎上，生成後續的排列。也就是說，如果要生成所有的permutation的話，那麼需要先將元素排序。

 OK！！用法已經詳解了，接下來便是要將該函式的真面目示人了。

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;
    }
  }
}

以上為STL中的版本，該函式實現原理如下：

在當前的序列中，從尾端出發往前找到一對相鄰的元素  a[ i ] 與 a[ j ] ，使得 a[ i ]  < a[ j ], （此處預設採用less函式物件），然後再從尾端出發找到一個字元  a[ k ] ,使得 a[ i ]  < a[ k ], 此時交換 a[ k ] 與 a[ i ], 並且將a[ j --- end) 之間的所有元素逆序即可。程式碼實現為：

template<class bidirectional_iterator>
bool permutation(bidirectional_iterator first, bidirectional_iterator last)
{
    if(first == last) return false; //如果沒有元素

    if(first + 1 == last) return false; //如果只有一個元素

    bidirectional_iterator j = last;
    --j;

    while(1)
    {
        bidirectional_iterator i = j;
        --i;
        //find a[i] < a[j] and they are adjacent
        if(*i < *j)
        {
            bidirectional_iterator k = last;
            while(!(*i < *--k)){}
            std::iter_swap(i,k); //或者是  swap(*i, *k);
            std::reverse(j,last);
            return true;
        }
        --j;
        //no such a[i] < a[i+1] pair found
        if( j == first)
        {
            //restore the first of the permutation
            std::reverse(first, last);
            return false;
        }
    }
}

上述程式碼中的swap函式必須是iter_swap函式，利用swap只是交換了迭代器的指標，並未實際改變元素的位。也可以使用swap(*i, *k);

關於該函式的comp物件的實際形式，接著會有一篇關於函式指標以及函式物件的博文，詳細講解。

2014 5.18 更新版本

看到網上的一篇文章的求解全排列：

如果只需要直接返回所有的全排列的話，那麼很簡單，依次交換字串中的相鄰的字元即可。

如下圖：