整数集合的若干种实现

最新推荐文章于 2020-03-31 12:10:22 发布
最新推荐文章于 2020-03-31 12:10:22 发布
阅读量1.7k 收藏
点赞数
分类专栏： 数据结构 文章标签： null insert report class struct iterator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuzhekai1985/article/details/6611286
版权

        本文用几种不同的数据结构，来实现整数集合的一些操作，比如插入、查找、遍历等。比较了它们的性能差异。实现中，应该注意两点，第一是集合的元素是不重复的，第二遍历输出时要求是按序输出。本文的代码主要参考了《编程珠玑》一书中的第13章 查找。完整代码在该书的附录部分。

         公共接口如下，接下来实现的类都是继承自这个类。

//公共接口
class IntSetImp
{
public:
	IntSetImp(int n) { maxNum=n; curNum=0; }
	virtual ~IntSetImp() {}
	virtual void Insert(int x)=0;           //插入
	virtual bool Find(int x)=0;             //查询
	virtual int Size()=0;                   //元素个数
	virtual void Report(int *visit)=0;      //遍历元素
protected:
	int maxNum;       //最大元素个数
	int curNum;       //当前个数
};

          （1）最简单的就是用C++自带的集合来实现，利用了设计模式中的适配器模式。插入和查找的时间复杂度都为O(logn)。代码如下：

//利用标准库的set实现
class IntSetSTL:public IntSetImp
{
private:
	set<int> S;
public:
	IntSetSTL(int n):IntSetImp(n) {}
	void Insert(int x)
	{
		if(S.size()<maxNum)
			S.insert(x);
	}
	int Size() { return S.size(); }
	bool Find(int x) { return (S.find(x)==S.end())?false:true;}
	void Report(int *visit)
	{
		int j=0;
		set<int>::iterator i;
		for(i=S.begin();i!=S.end();i++)
			visit[j++]=*i;
	}
};

        （2） 用数组实现，插入的时间复杂度为O(n)，查找的时间复杂度为O(logn)，因为是用二分查找实现查找功能的。

//整数数组实现
class IntSetArray:public IntSetImp
{
private:
	int *S;
public:
	IntSetArray(int n):IntSetImp(n) { S=new int[n];}
	~IntSetArray() { delete [ ] S; }
	int Size() {return curNum;};
	bool Find(int x) //二分查找的运用
	{
		int l,r,m;
		l=0;r=curNum;
		while(l<r){
			m=l+((r-l)>>1);
			if(S[m]<x)
				l=m+1;
			else if(S[m]==x)
				return true;
			else
				r=m;
		}
		return false;
	}
	void Insert(int x) 
	{
		if(curNum==maxNum||Find(x))  //已满或已存在
			return;
		int i;
		for(i=curNum-1;i>=0&&S[i]>x;i--) //找到插入位置
			S[i+1]=S[i];
		S[i+1]=x;
		curNum++;
	}
	void Report(int *visit)
	{
		for(int i=0;i<curNum;i++)
			visit[i]=S[i];
	}
};

         （3）用链表实现。插入和查找的时间复杂度都为O(n)

//链表实现
class IntSetList:public IntSetImp
{
	struct node
	{
		int data;
		node *next;
		node(int d=0,node *p=NULL) {data=d;next=p;}
	};
private:
	node *head; //头指针
public:
	IntSetList(int n):IntSetImp(n) { head=NULL; }
	~IntSetList() 
	{ 
		node *p=head;
		while(p!=NULL) 
		{
			node *q=p;
			p=p->next;
			delete q;
		}
	}
	int Size() {return curNum;};
	bool Find(int x) 
	{
		node *p=head;
		while(p!=NULL)
		{
			if(p->data==x)
				return true;
			p=p->next;
		}
		return false;
	}
	void Insert(int x) 
	{
		if(curNum==maxNum) 
			return;

		node *p=head,*q=NULL;
		while(p!=NULL&&p->data<x) //寻找插入位置
		{
			q=p;p=p->next;
		}
		if(p!=NULL&&p->data==x)  //已存在
			return;


		if(q==NULL)  //插在头部
			head=new node(x,p);
		else
			q->next=new node(x,p);
		curNum++;
	}
	void Report(int *visit)
	{
		int i=0;
		node *p=head;
		while(p!=NULL)
		{
			visit[i++]=p->data;
			p=p->next;
		}
	}
};

        （4）二分查找树实现。插入和查询的时间复杂度为O(logn)。

class IntSetBST:public IntSetImp
{
	struct node
	{
		int data;
		node *left;
		node *right;
		node(int d,node *r,node *l) { data=d; right=r;left=l;}
	};
private:
	node *root; //根节点
	int *tmpS;  //遍历时用到
	int tmpI;   //遍历时用到

	node* rInsert(node *p,int x)
	{
		if(p==NULL)
		{
			p=new node(x,NULL,NULL);
			curNum++;
		}
		else
		{
			if(p->data>x)
				p->left=rInsert(p->left,x);
			if(p->data<x)
				p->right=rInsert(p->right,x);
			//等于不处理
		}
		return p;
	}
	//中序遍历
	void rTraverse(node *p)
	{
		if(p==NULL)
			return;


		rTraverse(p->left);
		tmpS[tmpI++]=p->data;
		rTraverse(p->right);
	}
	void rDelete(node *p)
	{
		if(p==NULL)
			return;
		node *left=p->left;
		node *right=p->right;
		delete p;
		rDelete(left);
		rDelete(right);
	}
public:
	IntSetBST(int n):IntSetImp(n) { root=NULL;}
	~IntSetBST() { rDelete(root); }
	int Size(){return curNum;}
	bool Find(int x) 
	{
		node *p=root;
		while(p!=NULL)
		{
			if(x<p->data)
				p=p->left;
			else if(x>p->data)
				p=p->right;
			else
				return true;
		}
		return false;
	}
	void Insert(int t)
	{
		if(curNum<maxNum) 
			root=rInsert(root,t);
	}
	void Report(int *visit)
	{
		tmpS=visit;
		tmpI=0;
		rTraverse(root);
	}
};

       （5）利用位向量实现。查找与插入都可以在O(1)内实现，只是初始化的时间比较长。如果最大值比较小的话，那么非常好，空间和时间都可以接受。但是如果n很大的话，位向量需要的空间太大了。如果最大值可以是2^32 ，那么需要0.5G内存。

//位图实现
class IntSetBitVec:public IntSetImp
{
private:
	enum { BITWIDTH=32,MASK=0x1f,SHIFT=5};
	void set(int i) { S[i>>SHIFT] |= (1<< (i&MASK));}          //设置
	void clr(int i) { S[i>>SHIFT] &= ~(1<< (i&MASK));}       //复位
	int test(int i) { return S[i>>SHIFT] & (1<< (i&MASK));} //测试
	int *S;
	int maxVal; //允许的最大值
public:
	IntSetBitVec(int n,int max):IntSetImp(n) 
	{
		maxVal=max;
		S=new int [1+max/BITWIDTH];
		for(int i=0;i<max;i++)
			clr(i);
	}
	~IntSetBitVec() { delete []S; }
	int Size(){ return curNum; }
	void Insert(int t)
	{
		if(curNum==maxNum||test(t)) 
			return;

		set(t);
		curNum++;
	}
	void Report(int *visit)
	{
		int j=0;
		for(int i=0;i<maxVal;i++)
		{
			if(test(i))
				visit[j++]=i;
		}
	}
	bool Find(int x)
	{
		return test(x)?true:false;
	}
};

         （6）将位图技术与链表两种结构结合起来，其实就是散列，只不过散列函数比较特殊而已。

//结合链表和位图 散列的思想
class IntSetBins:public IntSetImp
{
	struct node
	{
		int data;
		node *next;
		node(int d,node *p) {data=d;next=p;}
	};
private:
	node **S;
	int maxVal;

public:
	IntSetBins(int n,int max):IntSetImp(n) 
	{
		maxVal=max;
		S=new node* [n];
		for(int i=0;i<n;i++)
			S[i]=NULL;
	}
	~IntSetBins() 
	{ 
		int i;
		for(i=0;i<maxNum;i++)
		{
			node *p=S[i];
			while(p!=NULL) 
			{
				node *q=p;
				p=p->next;
				delete q;
			}
		}
	}
	int Size(){ return curNum; }
	void Insert(int x)
	{
		int i=x/(1+maxVal/maxNum);

		//下面是链表的插入过程
		if(curNum==maxNum) 
			return;

		node *p=S[i],*q=NULL;
		while(p!=NULL&&p->data<x) //寻找插入位置
		{
			q=p;p=p->next;
		}
		if(p!=NULL&&p->data==x)  //已存在
			return;

		if(q==NULL)  //插在头部
			S[i]=new node(x,p);
		else
			q->next=new node(x,p);
		curNum++;
	}
	void Report(int *visit)
	{
		int i,j=0;
		for(i=0;i<maxNum;i++) //检查每个桶
		{
			for(node *p=S[i];p!=NULL;p=p->next)
				visit[j++]=p->data;
		}
	}
	bool Find(int x)
	{
		int i=x/(1+maxVal/maxNum); //散列到某个桶
		node *p=S[i];
		while(p!=NULL)
		{
			if(p->data==x)
				return true;
			p=p->next;
		}
		return false;
	}
};

       下面给出测试的驱动程序。通过调整N、MAX的值可以控制插入个数和允许的最大值

#include <iostream>
#include <algorithm>
#include <ctime>
#include <set>
using namespace std;
const int N=10000;               //整数个数
const int MAX=100000000; //最大值
int bigrand()  //产生大整数
{
	return RAND_MAX*rand()+rand();
}
void GenSets(int n,int maxval)
{
	long start,end,total=0;
	int tnum=10;
	for(int i=0;i<tnum;i++)
	{
		IntSetSTL S(n);
		//IntSetArray S(n);
		//IntSetList S(n);
		//IntSetBST S(n);
		//IntSetBitVec S(n,maxval);	
		//IntSetBins S(n,maxval);
		start=clock();
		while(S.Size()<n)
			S.Insert(bigrand()%maxval);
		end=clock();
		total+=(end-start);
	}
	cout<<"total time is : "<<total/(tnum*1000.0)<<'s'<<endl;

	//如果需要查看插入的元素，可以执行这段代码
	/*int *v=new int[n];
	S.Report(v);
	for(int j=0;j<n;j++)
	{
		cout<<v[j]<<' ';
		if(j%10==0&&j!=0)
			cout<<endl;
	}
	cout<<endl;*/
}

int main()
{
	srand(time(0));
	GenSets(N,MAX);
	return 0;
}

         当N取1000、20000、40000，MAX取100000000时，运行时间比较。这里最后两种结构未包含初始化的时间。

 N                                       10000                 20000                 40000

标准库                              0.034s                0.064s                0.145s          

数组                                  0.167s                0.667s                2.667s

链表                                  0.283s                1.156s                5.562s    

二叉查找树                      0.011s                0.023s                0.043s

位图                                  0.000s                0.003s                0.007s

位图+链表                        0.000s                0.006s                0.018s


时间复杂度对比

                                         插入                          查找

标准库                          O(logn)                  O(logn)  

数组                              O(n)                        O(logn)

链表                              O(n)                        O(n)    

二叉查找树                  O(logn)                  O(logn)

位图                              O(1)                        O(1)    

位图+链表                   O(n/m)                    O(n/m)     m为桶的个数

       在应用中，如果整数集合的最大值比较小，用位图比较好。如果最大值比较大，可以考虑用二叉树来实现。

    本人享有博客文章的版权，转载请标明出处 http://blog.csdn.net/wuzhekai1985

wuzhekai1985
关注
专栏目录
整数集合
qq_43271202的博客
07-06 1419
整数集合 背景 今天复习整数集合这种数据结构，这种数据结构是由存储权限而来的。 基本理论 含义 整数集合实质上是一个二进制串，他代表用户对于一连串功能的权限情况，若某位为1，代表具有该权限；若某位为0，代表不具有该权限。 而在存储的时候，我们利用一个无符号整型数组来存储这个二进制串，数组中每一个元素都是一个32位无符号整型，这一个元素代表一个32位的二进制串，也就代表32个功能的权限情况。 理解这...
定义一个整数集合类及相关运算
12-28
定义一个整数集合类 添加一个元素 删去一个元素 两个集合是否相等 集合的与、差、并、交
整数集合的实现
Jack Zhou的专栏
06-07 1165
问题：很多应用都需要搜索一组数据，比如编译器查找变量名以得到其地址，拼写检查器查找字典，DNS查找域名来获得IP地址。这与如何存储这些数据紧密相关。比如存储一组整数，如果用集合来存储，如何实现整数集合？
我的C实践(3)：用宏和位运算来实现整数集合
Jack Zhou的专栏
09-30 1452
    整数集合用一个位向量来表示。这里是无符号整数的集合，它适合存放范围在0~N-1之内的小整数，N是位向量的位数（这里为32位的unsigned int）。每个整数用集合中的一个位来表示，第i位为1(i=0~N-1)，当且仅当整数i属于集合。    1、头文件set.h：整数集合的接口。/* * set.h：整数集合，是一个位向量。适合存放范围在0~N-1之内的小整数，N是uns
【C++】类和对象编程练习——定义整数集合类
热门推荐
lanlanla的成长历程
09-05 1万+
定义整数集合类intSet.该类包括以下成员函数： inSet(); //类的构造函数，根据需要可以定义多个构造函数 int Empty(); //清空该整数集合 bool Isempty(); //判断整数集合是否为空 bool Ismemberof(...
Int类型的集合类的设计实现
请别抢我的狗熊
10-19 3254
在本实例中，定义了一个int类型的集合类。实现了比较常用的增加数据，删除数据，排序等的具体操作。 先上图： 增加一个数5，默认增加到最后一个位置 在3号位置增加一个数9 删除第三个数 删除数值为3的数 从小到大排序（冒泡） 从大到小排序 贴上代码如下;package HomeWork;import java.util.Arrays; /** * 定义一个可以存储Int类的集合类，使用一维数组存储数
数据结构：整数集合
soulmate______的博客
03-31 3735
整数集合 整数集合的定义：由若干互不相同的正整数组成的集合，其中全集为0至MaxRange，MaxRange为构成该集合元素的最大值 整数集合的操作： 向集合中添加元素 删除集合中的元素 判断元素是否属于该集合 得到集合中的所有元素 求两个集合的并集 求两个集合的交集 求两个集合的差集 求集合的补集 T：集合中元素的数据类型，对于整数集合来说是无符号整型u...
3.基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用链地址法处理冲突，实现散列查找算法，根据自动生成包含数百、数千、数万正整数的若干中正整数集合构造散列表，测量不同规模散列表的平均查找长度；
05-10
1. 生成包含数百、数千、数万正整数的若干中正整数集合。 2. 对于每个正整数集合，构造一个不同规模的散列表，并对其中的元素进行查找。 3. 计算每个散列表中所有查找操作的平均查找长度，并记录下来。 4. 绘制...
自动生成包含数百、数千、数万正整数的若干集合，作为构建不同规模查找表的基础。
05-12
为了自动生成包含数百、数千、数万正整数的若干集合，可以考虑以下方法： 1. 随机生成正整数并加入集合中。可以使用 Python 中的 random 模块来生成随机数，然后将生成的数加入集合中。可以使用集合数据结构来避免...
1. 自动生成包含数百、数千、数万正整数的若干集合，作为构建不同规模查找表的基础； 2. 基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用线性探测法处理冲突，实现散列查找算法，根据（1）中生成的正整数集合构造散列表，测量不同规模散列表的平均查找长度； 3. 基于散列表的工作原理，采用除留余数法H(key) = key % p (p<m) 作为散列函数，采用链地址法处理冲突，实现散列查找算法，根据（1）中生成的正整数集合构造散列表，测量不同规模散列表的平均查找长度；
05-12
1. 生成正整数集合：使用随机数生成算法生成包含数百、数千、数万个正整数的若干集合，作为构建不同规模查找表的基础。 2. 基于散列表的工作原理，采用除留余数法H(key) = key % p (p) 作为散列函数，采用线性探测...
java实现把一个List集合拆分成多个的操作
09-07
本篇文章将详细讲解如何使用Java实现将一个List集合拆分成多个固定长度的小集合。 首先，我们来看一个简单的例子，这个例子中定义了一个名为`groupList`的方法，它接受一个List类型的参数，并将其拆分成多个子集合...
程序实践系列（四）使用类设计整数集合类
松子茶的专栏
09-26 4627
设计整数集合类Set，该类包括以下数据成员：  int elem[N];        //存放集合元素  int num;            //集合中最后一个元素位置 和以下成员函数： Set();                        //默认构造函数  Set(int a[],ints);        //以数组a的元素和位置s构造一个集合  void empty();
幂集问题（即求全组合，全部子集问题）
qq_34581491的博客
11-30 1462
8、若S是n个元素的集合，则S的幂集P(S)定义为S的所有子集的集合。例如，S=(a,b,c),P(S)={(),(a),(b),(c),(a,b),(a,c),(b,c),(a,b,c)}。给定S，写一递归算法求P(S)。（本题20分） #include #include // 《数据结构》严蔚敏P150 例6.3 void PrintPowerSet(int i, int n) {
打印出数组的所有子集
AlgorithmEngine
07-24 1234
#include #include void printSets(int* a, int n) { int i = 1; int total = std::pow(2.0, n); int cur; int cnt = 1; while(i < total) { std::cout << "Possibility " << cnt << ": "; cur = i;
实现一个操作集合的类
不积跬步无以至千里
04-04 911
c++实验课作业：实现整型集合的增、删、清空、求元素数目、输出所有元素、求交并集…… 类头文件：   #ifndef CLASS_H_INCLUDED #define CLASS_H_INCLUDED #include &lt;string.h&gt; //包含memset class Set { public: int items[20]; int number; Set(...
AI企联系统 Ai企业级系统开心版 uniapp适配 Web+H5+微信小程序+抖音小程序+双端APP
最新发布
11-12
AI企联系统 Ai企业级系统开心版 uniapp适配 Web+H5+微信小程序+抖音小程序+双端APP 一款市面上新出的AI企联系统，项目uniapp开发的，支持3.5 4.0 Mj，此套系统5端适配，Web+H5+微信小程序+抖音小程序+双端APP，支持流量主! 自己有能力的可以二开，UI后台也可以自己改。
2000d.doc
11-12
2000d
实现两组整数异或集的算法解析
# 读取两行输入，每行包含若干整数 first_set = set(map(int, input().split())) second_set = set(map(int, input().split())) # 求两组整数的异或集 xor_set = {x ^ y for x in first_set for y in second_set} ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值