高效率的排列组合算法（java实现）

 

1. package BeanUtil;
3. import java.util.ArrayList;
4. import java.util.List;
6. import com.work.core.exception.OurException;
8. /**
9.  * 统计任三出现的最多的几率的组合
10.  * 
11.  * @author wangmingjie
12.  * @date 2009-1-1下午01:22:19
13.  */
14. public class Copy_2_of_StatisAnyThree {
15. //  组合算法   
16. //    本程序的思路是开一个数组，其下标表示1到m个数，数组元素的值为1表示其下标   
17. //    代表的数被选中，为0则没选中。     
18. //    首先初始化，将数组前n个元素置1，表示第一个组合为前n个数。     
19. //    然后从左到右扫描数组元素值的“10”组合，找到第一个“10”组合后将其变为   
20. //    “01”组合，同时将其左边的所有“1”全部移动到数组的最左端。     
21. //    当第一个“1”移动到数组的m-n的位置，即n个“1”全部移动到最右端时，就得   
22. //    到了最后一个组合。     
23. //    例如求5中选3的组合：     
24. //    1   1   1   0   0   //1,2,3     
25. //    1   1   0   1   0   //1,2,4     
26. //    1   0   1   1   0   //1,3,4     
27. //    0   1   1   1   0   //2,3,4     
28. //    1   1   0   0   1   //1,2,5     
29. //    1   0   1   0   1   //1,3,5     
30. //    0   1   1   0   1   //2,3,5     
31. //    1   0   0   1   1   //1,4,5     
32. //    0   1   0   1   1   //2,4,5     
33. //    0   0   1   1   1   //3,4,5   
34.     public static void main(String[] args) {
35.         Copy_2_of_StatisAnyThree s = new Copy_2_of_StatisAnyThree();
36.         s.printAnyThree();      
37.     }
38.     
39.     /**
40.      * 
41.      */
42.     public void printAnyThree(){
43.         int[] num = new int[]{1,2,3,4,5,6};
44.         print(combine(num,3));
45.     }
47.     /**
48.      * 从n个数字中选择m个数字
49.      * @param a
50.      * @param m
51.      * @return
52.      */
53.     public List combine(int[] a,int m){
54.         int n = a.length;
55.         if(m>n){
56.             throw new OurException("错误！数组a中只有"+n+"个元素。"+m+"大于"+2+"!!!");
57.         }
58.         
59.         List result = new ArrayList();
60.         
61.         int[] bs = new int[n];
62.         for(int i=0;i<n;i++){
63.             bs[i]=0;
64.         }
65.         //初始化
66.         for(int i=0;i<m;i++){
67.             bs[i]=1;
68.         }
69.         boolean flag = true;
70.         boolean tempFlag = false;
71.         int pos = 0;
72.         int sum = 0;
73.         //首先找到第一个10组合，然后变成01，同时将左边所有的1移动到数组的最左边
74.         do{
75.             sum = 0;
76.             pos = 0;
77.             tempFlag = true; 
78.             result.add(print(bs,a,m));
79.             
80.             for(int i=0;i<n-1;i++){
81.                 if(bs[i]==1 && bs[i+1]==0 ){
82.                     bs[i]=0;
83.                     bs[i+1]=1;
84.                     pos = i;
85.                     break;
86.                 }
87.             }
88.             //将左边的1全部移动到数组的最左边
89.             
90.             for(int i=0;i<pos;i++){
91.                 if(bs[i]==1){
92.                     sum++;
93.                 }
94.             }
95.             for(int i=0;i<pos;i++){
96.                 if(i<sum){
97.                     bs[i]=1;
98.                 }else{
99.                     bs[i]=0;
100.                 }
101.             }
102.             
103.             //检查是否所有的1都移动到了最右边
104.             for(int i= n-m;i<n;i++){
105.                 if(bs[i]==0){
106.                     tempFlag = false;
107.                     break;
108.                 }
109.             }
110.             if(tempFlag==false){
111.                 flag = true;
112.             }else{
113.                 flag = false;
114.             }
115.             
116.         }while(flag);
117.         result.add(print(bs,a,m));
118.         
119.         return result;
120.     }
121.     
122.     private int[] print(int[] bs,int[] a,int m){
123.         int[] result = new int[m];
124.         int pos= 0;
125.         for(int i=0;i<bs.length;i++){
126.             if(bs[i]==1){
127.                 result[pos]=a[i];
128.                 pos++;
129.             }
130.         }
131.         return result ;
132.     }
133.     
134.     private void print(List l){
135.         for(int i=0;i<l.size();i++){
136.             int[] a = (int[])l.get(i);
137.             for(int j=0;j<a.length;j++){
138.                 System.out.print(a[j]+"/t");
139.             }
140.             System.out.println();
141.         }
142.     }
143. }