转载自：http://blog.csdn.net/yzl20092856/article/details/39995085
求集合的所有子集的算法
对于任意集合A，元素个数为n（空集n=0），其所有子集的个数为2^n个
如集合A={a,b,c},其子集个数为8；对于任意一个元素，在每个子集中，
要么存在，要么不存在，对应关系是：
a->1或a->0
b->1或b->0
c->1或c->0
映射为子集：
(a,b,c)
(1,1,1)->(a,b,c)
(1,1,0)->(a,b )
(1,0,1)->(a, c)
(1,0,0)->(a )
(0,1,1)->( b,c)
(0,1,0)->( b )
(0,0,1)->( c)
(0,0,0)->@(@表示空集)
算法（1）：
观察以上规律，与计算机中数据存储方式相似，故可以通过一个整型数（int）与
集合映射000...000 ~ 111...111（0表示有，1表示无，反之亦可），通过该整型数
逐次增1可遍历获取所有的数，即获取集合的相应子集。
在这里提一下，使用这种方式映射集合，在进行集合运算时，相当简便，如
交运算对应按位与&，{a,b,c}交{a,b}得{a,b}<--->111&110==110
并运算对应按位或|，
差运算对应&~。
算法（2）：
设函数f(n)=2^n (n>=0)，有如下递推关系f(n)=2*f(n-1)=2*(2*f(n-2))
由此可知，求集合子集的算法可以用递归的方式实现，对于每个元素用一个映射列表marks，标记其
在子集中的有无
很显然，在集合元素个数少的情况下，算法（1）优于算法（2），因为只需通过加法运算，便能映射
出子集，而算法（2）要递归调用函数，速度稍慢。但算法（1）有一个严重缺陷，集合的个数不能大于在
计算机中一个整型数的位数，一般计算机中整型数的为32位。对于算法（2）就没这样限制。
1. template<class T>
2. void print(T a[],int mark,int length)
3. {
4. bool allZero=true;
5. int limit=1<<length;
6. for(int i=0;i<length;++i)
7. {
8. if(((1<<i)&mark)!=0) //mark第i+1位为1，表示取该元素
9. {
10. allZero=false;
11. cout<<a[i]<<" ";
12. }
13. }
14. if(allZero==true)
15. {
16. cout<<"@";
17. }
18. cout<<endl;
19. }
20.
21. template<class T>
22. void subset(T a[],int length)
23. {
24. if(length>31) return;
25. int lowFlag=0; //对应000...000
26. int highFlag=(1<<length)-1; //对应111...111
27. for(int i=lowFlag;i<=highFlag;++i)
28. {
29. print(a,i,length);
30. }
31.
32. } template<class T>
void print(T a[],bool marks[],int length)
{ bool allFalse=true; for(int i=0;i<length;++i) { if(marks[i]==true) { allfalse=false; cout<<a[i]<<" "; } } if(allFalse==true) { cout<<"@"; } cout<<endl; } template<class T>
void subset(T a[],bool marks[],int m,int n,int length)
{ if(m>n) { print(a,marks,length); } else { marks[m]=true; subset(a,marks,m+1,n,length); marks[m]=false; subset(a,marks,m+1,n,length); } } 
