全排列（一）next_permutation方式实现

1、next_permutation函数简介

(1) 原理：

每个序列都对应一个数值（并非原理，只是一种理解方式，也可以当做是一个序列与数值的映射关系，数值范围取决于参与排列元素的个数，记住这种思路）

（原理将在下篇博客介绍）

（此种理解方式的原文链接：http://www.cppblog.com/yindf/archive/2010/02/24/108312.html）

原排列                  中间转换                值
1，2，3，4        3，2，1            ((3 * (3) + 2) * (2) + 1) * (1) = 23
1，2，4，3        3，2，0            ((3 * (3) + 2) * (2) + 0) * (1) = 22
1，3，2，4        3，1，1            ((3 * (3) + 1) * (2) + 1) * (1) = 21
1，3，4，2        3，1，0            ((3 * (3) + 1) * (2) + 0) * (1) = 20
1，4，3，2        3，0，1            ((3 * (3) + 0) * (2) + 1) * (1) = 19
.                  .                     .
.                  .                     .
.                  .                     .
4，3，2，1        0，0，0            ((0 * (3) + 0) * (2) + 0) * (1) = 0
                               |      |      |                       |                    |                   |
                               |      |                              |                    |
                               |                                     |

 上面的中间转换指的是：每一个数字后面比当前位数字大的数字的个数。比如：

1，3，4，2  中，1 后面有(3, 4, 2) 他们都大于1，所以第一位是 3
                              3 后面有(4, 2), 但只有4大于3，所以第二位是 1
                              4 后面有(2), 没有比4 大的，所以第三位是 0
                              最后一位后面肯定没有更大的，所以省略了一个0。

经过这种转换以后，就得到了一种表示方式（中间转换），这种表达方式和原排列一一对应，可以相互转化。

仔细观察这种中间表达方式，发现它的第一位只能是（0，1，2，3），第二位只能是（0，1，2），第三位只能是（0，1）。通常，数字是用十进制表示的，计算机中用二进制，但是现在，我用一种特殊的进制来表示数：

第一位用1进制，第二位用2进制。。。

于是就得到了这种中间表示方式的十进制值。如：

                                                              阶                  
                                            |                  |                    |
1，1，0    ---->   ((1 * (3) + 1) * (2) + 0) * (1) = 8

3，1，0    ---->   ((3 * (3) + 1) * (2) + 0) * (1) = 20

这样，就可以得到一个十进制数和一个排列之间的一一对应的关系。
现在排列数和有序的十进制数有了一一对应的关系（通过改变对应关系，可以使十进制数升序）。

(2) 函数形式：

a.默认形式：
template <class BidirectionalIterator>
  bool next_permutation (BidirectionalIterator first,
                         BidirectionalIterator last);
b.定制形式：
template <class BidirectionalIterator, class Compare>
  bool next_permutation (BidirectionalIterator first,
                         BidirectionalIterator last, Compare comp);

c.简洁形式：

#include<algorithm>

bool next_perrmutation(num,num+len)

(3)单词

iterator [ɪtə'retɚ]  permutation  ['pɝmjʊ'teʃən] 排列，置换 algorithm ['ælgə'rɪðəm]

2、代码

（1）默认形式

需要注意的是，next_permutation()函数是产生是有顺序的，所以初始序列一定要是升序，某则给出排序是初始序列后的结果。

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int num[3]={1,2,3};

    cout << "初始序列：" << num[0] << " " << num[1] << " " << num[2] << endl<<endl;
    do
    {
        cout<<num[0]<<" "<<num[1]<<" "<<num[2]<<endl;
    }while(next_permutation(num,num+3));
    return 0;
}

初始序列对结果的影响：

（2）定制形式（针对类对象的全排列）

注意：

I.需要自己构造类的比较函数

II.需要重载类的等号运算符

#include<iostream>
#include<algorithm>
using namespace std;
class node     //注意类编程的形式
{
    public:
    int data;
    void set(int a); //声明
    node & operator =(node n); //运算符重载形式
};
void node::set(int a)  //类成员函数定义
{
    data=a;
}
node & node::operator =(node n)  //运算符重载形式
{
    data=n.data;
    return *this;
}
bool comp(node a,node b)
{
    return a.data<b.data;
}
int main()
{
    node num[3];
    for(int i=0;i<3;i++)
    {
        num[i].set(i+1);
    }
    cout<<"初始序列： "<<num[0].data<<" "<<num[1].data<<" "<<num[2].data<<endl;
    do
    {
        cout<<num[0].data<<" "<<num[1].data<<" "<<num[2].data<<endl;
    }while(next_permutation(num,num+3,comp));
    return 0;
}