【算法】排列组合算法

0x55AA

排列算法：
排列算法采用递归思想很简单。如1，2，3，4我们求其排列。
首先遍历1,2,3,4.
遍历1，剩下2,3,4递归处理
遍历2，剩下1,3,4递归处理
遍历3，剩下1,2,4递归处理
遍历4，剩下1,2,3递归处理
我们的目标是把相应的排列给答应出来，所以这个时候需要一个数组来保存已经处理的数字。但是关于数组的下标在递归的时候是个问题，我们改采取怎样的方式呢？可以发现这里有一个技巧，用原始数组的长度减去当前待处理的数组的长度就得到元素的数组索引。如刚开时候是1,2,3,4。数组长度等于原始数组长度，所以1的索引是0。处理1之后，剩下2,3,4，此时数组长度是3，所以我们把2的数组索引定义为4-3=1。以此类推，直到数组的长度为1。
组合算法：
组合的思想和排列一样，只不过组合之间的元素不需要前后前后顺序要求，所以我们需要排除在排列中重复的元素。关于去除的思想，我们在这里可以采取一种简单的方法，我们将组合的元素按顺序排列，保证后面的元素大于前面的元素，这样就可以实现无重复了。
如 ，我们这样处理：
1，2；
1，3；
1，4；
2，3；
2，4；
3，4；
这样按照从小到大的顺序从而实现了无重复的排列。
关于组合，稍微麻烦的是在处理数组的元素下标，想了好久想到到了一个比较拙劣的办法，实属本人不才。我在函数的参数列表中加了一个参数k，来表示数组元素下标。当采用递归的时候，说明要产生下一个数组元素，所以k++，递归调用完毕后，我们要依次遍历后面的元素，所以要k--。
实现代码：
一个三个函数按照顺序分别表示的是： 的算法。

1. #include<iostream>
   
2. #include<list>
   
3. #include<vector>
   
4. using namespace std;
   
5. void arrangeN(list<int> &Lis,vector<int> &Vec);
   
6. void arrangeK(list<int> &Lis,vector<int> &Vec,int nK,int nN);
   
7. void combineK(list<int> &Lis,vector<int> &Vec,int nK,int nN,int k);
   
8. void main()
   
9. {
   
10.         int n1 = 10;
    
11.         list<int> Arra;
    
12.         vector<int> Vec(n1);
    
13.        
    
14.         //for(int i=1;i<=n;i++)
    
15.         //        Arra.push_back(i);
    
16.         //arrangeN(Arra,Vec);
    
17.         int n2 = 5;
    
18.         int nk = 4;
    
19.         for(int i=1;i<=n2;i++)
    
20.                 Arra.push_back(i);
    
21.         //arrangeK(Arra,Vec,n2,n2);
    
22.         combineK(Arra,Vec,nk,n2,0);
    
23. }
    
24. 
    
25. void arrangeN(list<int> &Lis,vector<int> &Vec)
    
26. {
    
27.         list<int>::iterator iter;
    
28.         int nSize = Lis.size();
    
29.         int nLength = Vec.size();
    
30.         for(iter = Lis.begin();iter != Lis.end();iter++)
    
31.         {
    
32.                 Vec[nLength-nSize] = *iter;
    
33.                 if(nSize == 1)
    
34.                 {
    
35.                         for(int i=0;i<nLength;i++)
    
36.                                 cout<<Vec[i]<<"  ";
    
37.                         cout<<endl;
    
38.                 }
    
39.                 list<int> Lisc(Lis);
    
40.                 Lisc.remove(*iter);
    
41.                 arrangeN(Lisc,Vec);
    
42.                
    
43.         }
    
44. }
    
45. 
    
46. void arrangeK(list<int> &Lis,vector<int> &Vec,int nK,int nN)
    
47. {
    
48.         list<int>::iterator iter;
    
49.         int nSize = Lis.size();
    
50. 
    
51.         for(iter = Lis.begin();iter != Lis.end();iter++)
    
52.         {
    
53.                 Vec[nN-nSize] = *iter;
    
54.                 if(nN-nSize +1 == nK)
    
55.                 {
    
56.                         for(int i=0;i<nK;i++)
    
57.                                 cout<<Vec[i]<<"  ";
    
58.                         cout<<endl;
    
59.                 }
    
60.                 list<int> Lisc(Lis);
    
61.                 Lisc.remove(*iter);
    
62.                 arrangeK(Lisc,Vec,nK,nN);       
    
63.         }
    
64. }
    
65. 
    
66. void combineK(list<int> &Lis,vector<int> &Vec,int nK,int nN,int k)
    
67. {
    
68.         int nSize = Lis.size();
    
69.         list<int>::iterator iter;
    
70.         for(iter = Lis.begin();iter != Lis.end();iter++)
    
71.         {
    
72.                 if(nN - nSize == 0)
    
73.                         k = 0;
    
74.                 Vec[k] = *iter;
    
75.                 if( k + 1 == nK)
    
76.                 {
    
77.                         for(int j=0;j<nK;j++)
    
78.                                 cout<<Vec[j]<<"  ";
    
79.                         cout<<endl;
    
80.                 }
    
81.                 else
    
82.                 {
    
83.                         list<int> Lisc( ++iter,Lis.end() );
    
84.                         iter--;
    
85.                         k++;
    
86.                         combineK(Lisc,Vec,nK,nN,k);
    
87.                         k--;
    
88.                 }
    
89.         }
    
90. }

复制代码

测试结果：
4!