集合的所有子集的算法

转载自：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);   
    }  
  
}