数据结构与算法C++实现8：递归的排列组合（Permutations）

1 abc 经过排列组合有八种 abc, acb, bac, bca, cab, cba
2 要点：

void Permutations(char* p, const int k, const int m)
{
                                            // b开头的，后面跟着c所有的排列
                                            std::swap(p[1], p[1]);
                                            Permutations(p, 2, 2);      如果k == m  打印此时的p指针指向的内容 循环输出 abc
                                            std::swap(p[1], p[1]);
    // a开头的，后面跟着bc所有的排列
    std::swap(p[0], p[0]);
    Permutations(p, 1, 2);
    std::swap(p[0], p[0]);
                                            // c开头的，后面跟着b所有的排列
                                            std::swap(p[1], p[2]);
                                            Permutations(p, 2, 2);      如果k == m  打印此时的p指针指向的内容 循环输出 acb
                                            std::swap(p[1], p[2]);





                                            // a开头的，后面跟着c所有的排列
                                            std::swap(p[1], p[1]);
                                            Permutations(p, 2, 2);      如果k == m  打印此时的p指针指向的内容 循环输出 bac
                                            std::swap(p[1], p[1]);
    // b开头的，后面跟着ac所有的排列
    std::swap(p[0], p[1]);  // 交换 a b 位置
    Permutations(p, 1, 2);
    std::swap(p[0], p[1]);  // 还原 a b 位置

                                            // c开头的，后面跟着a所有的排列
                                            std::swap(p[1], p[2]);
                                            Permutations(p, 2, 2);      如果k == m  打印此时的p指针指向的内容 循环输出 bca
                                            std::swap(p[1], p[2]);






                                            // a开头的，后面跟着b所有的排列
                                            std::swap(p[1], p[1]);
                                            Permutations(p, 2, 2);      如果k == m  打印此时的p指针指向的内容 循环输出 cab
                                            std::swap(p[1], p[1]);
    // c开头的，后面跟着ab所有的排列
    std::swap(p[0], p[2]);  // 交换 a c 位置
    Permutations(p, 1, 2);
    std::swap(p[0], p[2]);  // 还原 a c 位置
                                            // b开头的，后面跟着a所有的排列
                                            std::swap(p[1], p[2]);
                                            Permutations(p, 2, 2);      如果k == m  打印此时的p指针指向的内容 循环输出 cba
                                            std::swap(p[1], p[2]);
}

3 见案例（diguipailiezuhe.cpp）

//
// Created by z on 20-2-11.
// 演示递归的排列组合
//
#include 

using namespace std;

// 递归的排列组合函数  arg1:char*类型的指针，指向需要进行排列组合的字符串  arg2:需要进行排列组合字符串的开始位置  arg3:需要进行排列组合字符串的终止位置
void Permutations(char* p, const int k, const int m)
{
    if(k == m)
    {
        for(int i = 0; i <= m; i++)
            cout << p[i];
        cout << endl;
    }

    else
    {
        for(int i = k; i <= m; i++)             // 好好理解这段代码，非常巧妙
        {
            swap(p[k], p[i]);
            Permutations(p, k + 1, m);
            swap(p[k], p[i]);
        }
    }

}

int main()
{
    char a[] = "abc";
    Permutations(a, 0, 2);
    return 0;
}