面试题精选（63）：排列算法

全排列算法有两个比较常见的实现：递归排列和字典序排列。

（1）递归实现
从集合中依次选出每一个元素，作为排列的第一个元素，然后对剩余的元素进行全排列，如此递归处理，从而得到所有元素的全排列。算法实现如下：

#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
void CalcAllPermutation_R(T perm[], int first, int num)
{
    if (num <= 1) {
        // 得到一个排列
//        int count = first + num;
//        for (int i = 0; i < count; ++i)
//            cout << perm[i] << ' ';
//        cout << '/n';
        return;
    }
   
    for (int i = first; i < first + num; ++i) {
        swap(perm[i], perm[first]);
        CalcAllPermutation_R(perm, first + 1, num - 1);
        swap(perm[i], perm[first]);
    }
}

int main()
{
    const int NUM = 12;
    char perm[NUM];
   
    for (int i = 0; i < NUM; ++i)
        perm[i] = 'a' + i;
   
    CalcAllPermutation_R(perm, 0, NUM);
}

程序运行结果（优化）：
-bash-3.2$ g++ test.cpp -O3 -o ttt
-bash-3.2$ time ./ttt

real    0m10.556s
user    0m10.551s
sys     0m0.000s

程序运行结果（不优化）：
-bash-3.2$ g++ test.cpp -o ttt
-bash-3.2$ time ./ttt

real    0m21.355s
user    0m21.332s
sys     0m0.004s

（2）字典序排列
把升序的排列（当然，也可以实现为降序）作为当前排列开始，然后依次计算当前排列的下一个字典序排列。对当前排列从后向前扫描，找到一对为升序的相邻元素，记为i和j（i < j）。如果不存在这样一对为升序的相邻元素，则所有排列均已找到，算法结束；否则，重新对当前排列从后向前扫描，找到第一个大于i的元素k，交换i和k，然后对从j开始到结束的子序列反转，则此时得到的新排列就为下一个字典序排列。这种方式实现得到的所有排列是按字典序有序的，这也是C++ STL算法next_permutation的思想。算法实现如下：

#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
void CalcAllPermutation(T perm[], int num)
{
    if (num < 1)
        return;
   
    // 输出第一个排列
//    for (int i = 0; i < num; ++i)
//        cout << perm[i] << ' ';
//    cout << '/n';
   
    while (true) {
        int i;
        for (i = num - 2; i >= 0; --i) {
            if (perm[i] < perm[i + 1])
                break;
        }
       
        if (i < 0)
            break;  // 已经找到所有排列
   
        int k;
        for (k = num - 1; k > i; --k) {
            if (perm[k] > perm[i])
                break;
        }
       
        swap(perm[i], perm[k]);
        reverse(perm + i + 1, perm + num);
       
        // 得到一个新的排列
//        for (int i = 0; i < num; ++i)
//            cout << perm[i] << ' ';
//        cout << '/n';
    }
}

int main()
{
    const int NUM = 12;
    char perm[NUM];
   
    for (int i = 0; i < NUM; ++i)
        perm[i] = 'a' + i;
   
    CalcAllPermutation(perm, NUM);
}

程序运行结果（优化）：
-bash-3.2$ g++ test.cpp -O3 -o ttt
-bash-3.2$ time ./ttt

real    0m3.055s
user    0m3.044s
sys     0m0.001s

程序运行结果（不优化）：
-bash-3.2$ g++ test.cpp -o ttt
-bash-3.2$ time ./ttt

real    0m24.367s
user    0m24.321s
sys     0m0.006s

使用std::next_permutation来进行对比测试，代码如下：
#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
size_t CalcAllPermutation(T perm[], int num)
{
    if (num < 1)
        return 0;
   
    // 输出第一个排列
//    for (int i = 0; i < num; ++i)
//        cout << perm[i] << ' ';
//    cout << '/n';
   
    size_t count = 0;
    while (next_permutation(perm, perm + num)) {
        ++count;
       
        // 得到一个新的排列
//        for (int i = 0; i < num; ++i)
//            cout << perm[i] << ' ';
//        cout << '/n';
    }
   
    return count;
}

int main()
{
    const int NUM = 12;
    char perm[NUM];
   
    for (int i = 0; i < NUM; ++i)
        perm[i] = 'a' + i;
   
    size_t count = CalcAllPermutation(perm, NUM);
   
    return count;
}

程序运行结果（优化）：
-bash-3.2$ g++ test.cpp -O3 -o ttt
-bash-3.2$ time ./ttt

real    0m3.606s
user    0m3.601s
sys     0m0.002s

程序运行结果（不优化）：
-bash-3.2$ g++ test.cpp -o ttt
-bash-3.2$ time ./ttt

real    0m33.850s
user    0m33.821s
sys     0m0.006s

测试结果汇总一（优化）：
（1）递归实现：0m10.556s
（2-1）字典序实现：0m3.055s
（2-2）字典序next_permutation：0m3.606s

测试结果汇总二（不优化）：
（1）递归实现：0m21.355s
（2-1）字典序实现：0m24.367s
（2-2）字典序next_permutation：0m33.850s

由测试结果可知，自己实现的字典序比next_permutation稍微快点，原因可能是next_permutation版本有额外的函数调用开销；而归实现版本在优化情况下要慢很多，主要原因可能在于太多的函数调用开销，但在不优化情况下执行比其它二个版本要快，原因可能在于程序结构更简单，执行的语句较少。

比较而言，递归算法结构简单，适用于全部计算出所有的排列（因此排列规模不能太大，计算机资源会成为限制）；而字典序排列逐个产生、处理排列，能够适用于大的排列空间，并且它产生的排列的规律性很强。