排列算法及组合算法（C++）

元素的排列算法

算法分析（递归方式）

• 设R={r₁ ,r₂, r₃,…….., r_n}是要进行排列的n个元素，R_i=R-{r_i}。集合X中的元素的全排列记为Perm（X）。（r_i）Perm（X）表示全排列Perm（X）的每一个排列前加上前缀r_i得到的排列。R的全排列可归纳定义如下：
  当n=1时，Perm（R）=（r），其中r是集合R中唯一的元素；
  当n>1时，Perm（R）由（r₁）Perm(R₁), （r₂）Perm(R₂),…,（r_n）Perm(R_n)构成。
  依次递归定义，可设计产生Perm（R）的递归算法如下：

template<class Type>
inline void swap(Type &a, Type %b)
{
    Type temp=a;
    a=b;
    b=temp;
}

template<class Type>
void Perm(Type list[], int k, int m)
{    //产生list[k...m]的所有排列 
    if(k==m)
    {
        //只剩下一个元素
        for(int i=0; i<=m; i++)
            cout <<list[i];
        cout <<endl;
    } 
    else   //还有多个元素待排列，递归产生排列 
        for(int i=k; i<=m; i++)
        {
            swap(list[k], list[i]);
            perm(list, k+1, m);
            swap(list[k], list[i]); //交换回来以免产生相同的前缀 
        }
}

元素的组合算法

1）.算法分析（递归方式）

• 首先从n个数中选取编号最大的数，然后在剩下的n-1个数里面选取m-1个数，直到从n-(m-1)个数中选取1个数为止。
• 从n个数中选取编号次小的一个数，继续执行1步，直到当前可选编号最大的数为m。
  很明显，上述方法是一个递归的过程，也就是说用递归的方法可以很干净利索地求得所有组合。
  下面是递归方法的实现：

/*从数组a[0...n-1]中选取m个数的所有组合
  a[0...n-1]表示候选集，n表示候选集大小，其中n>=m>0
  b[0...M-1]用来存储当前组合中的元素（这里存储的是元素的下标）
  常量M表示一个组合中的元素个数，初始时M=m，参数M仅用来输出结果
*/
void combination(int a[], int n, int m, int b[], const int M)
{
    for (int i = n; i >= m; i--)   // 注意这里的循环范围
    {
        b[m - 1] = i - 1;         //存储末元素的标号
        if (m > 1)
            combination(a, i - 1, m - 1, b, M);
        else                     // m == 1, 输出一个组合
        {
            for (int j = M - 1; j >= 0; j--)
                cout << a[b[j]] << " ";
            cout << endl; 
        }
    }
}

2）.算法分析（01转换法）

• 本程序的思路是开一个数组，其下标表示1到n个数，数组元素的值为1表示其代表的数被选中，为0则没选中。
  首先初始化，将数组前m个元素置1，表示第一个组合为前m个数。
  然后从左到右扫描数组元素值的“10”组合，找到第一个“10”组合后将其变为“01”组合，同时将其左边(即现在这个01组合的左边)的所有“1”全部移动到数组的最左端。
  当第一个“1”移动到数组的n-m的位置，即n个“1”全部移动到最右端时，就得到了最后一个组合。

例如求5中选3的组合：

1 1 1 0 0 //1,2,3

1 1 0 1 0 //1,2,4

1 0 1 1 0 //1,3,4

0 1 1 1 0 //2,3,4

1 1 0 0 1 //1,2,5

1 0 1 0 1 //1,3,5

0 1 1 0 1 //2,3,5

1 0 0 1 1 //1,4,5

0 1 0 1 1 //2,4,5

0 0 1 1 1 //3,4,5

排列组合一起使用

n个数中求出m个数的组合和排列

源代码如下

// Permutation And Combination.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;
/*Analysis*/
/*以在n个数中选取m(0<m<=n)个数为例，问题可分解为：
1. 首先从n个数中选取编号最大的数，然后在剩下的n-1个数里面选取m-1个数，直到从n-(m-1)个数中选取1个数为止。
2. 从n个数中选取编号次小的一个数，继续执行1步，直到当前可选编号最大的数为m。
很明显，上述方法是一个递归的过程，也就是说用递归的方法可以很干净利索地求得所有组合。*/



void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

//产生list[k:m]的所有排列；初始k等于0，m等于末标
void permuation(int a[], int list[], int k, int m)
{
    if (k == m)
    {
        for (int i = 0; i <= m; i++)
            cout << a[list[i]];
        cout << endl;
    }
    else
        for (int i = k; i <= m; i++)
        {
            swap(list[k], list[i]);
            permuation(a, list, k + 1, m);
            swap(list[k], list[i]);
        }
}


/*从数组a[0...n-1]中选取m个数的所有组合
  a[0...n-1]表示候选集，n表示候选集大小，其中n>=m>0
  b[0...M-1]用来存储当前组合中的元素（这里存储的是元素的下标）
  常量M表示一个组合中的元素个数，初始时M=m，参数M仅用来输出结果
*/
void combination(int a[], int n, int m, int b[], const int M)
{
    for (int i = n; i >= m; i--)   // 注意这里的循环范围
    {
        b[m - 1] = i - 1;         //存储最后一个元素的标号
        if (m > 1)
            combination(a, i - 1, m - 1, b, M);
        else                     // m == 1, 输出一个组合
        {
            for (int j = M - 1; j >= 0; j--)
                cout << a[b[j]] << " ";
            cout << endl << "排列：" << endl;
            permuation(a, b, 0, M - 1);
            cout << endl; 
        }
    }
}

int main()
{
    const int N = 10;
    const int M = 3;
    int a[N];
    int b[M];
    for (int i = 0; i<N; i++)
        a[i] = i + 1;             //初始化a[]数组

    // 递归方法
    combination(a, N, M, b, M);
    return 0;
}

运行测试结果如下