整数集合的实现

  问题：很多应用都需要搜索一组数据，比如编译器查找变量名以得到其地址，拼写检查器查找字典，DNS查找域名来获得IP地址。这与如何存储这些数据紧密相关。比如存储一组整数，如果用集合来存储，如何实现整数集合？
  我们一般实现有序整数集合，这样就可以使用二分搜索搜索来快速进行搜索。为简单起见，下面的各种方案只集中于算法的关键部分，并没有考虑错误处理、虚构函数释放资源、拷贝构造等问题。
  （1）用标准模板库set来实现：通常标准模板库set是使用平衡二叉树来实现的。

class IntSetSTL{private:std::set<int> S;public:IntSetSTL(int maxelms,int maxval){ }int size(){ return S.size(); }//向集合中添加一个整数（如果集合中原先没有这个整数的话）void insert(int t){ S.insert(t); }void report(int *v){ //将元素写入到向量中int j=0;std::set<int>::iterator i;for(i=S.begin();i!=S.end();++i)v[j++]=*i;}};

  （2）用数组实现：适用于事先知道集合大小的情况。使用了一个哨兵元素，放置一个充分大的数（比集合中任何的元素都大）。这样一旦搜索到这个数，表明到达列表末尾，从而可以简化插入代码，提高运行速度。数组的优点就是可以随机访问。

class IntSetArray{private:int n,*x;public:IntSetArray(int maxelms,int maxval){x=new int[1+maxelms]; //多分配一个空间给哨兵用n=0;x[0]=maxval; //maxval放在末尾的哨兵元素处}int size() { return n; }void insert(int t){for(int i=0;x[i]<t;i++);if(x[i]==t) //集合中已经存在元素treturn;for(int j=n;j>=i;j--) //将大于t的元素向右移一个位置，将t插入到空出的位置处x[j+1]=x[j];x[i]=t;n++;}void report(int *v){for(int i=0;i<n;i++)v[i]=x[i];}};

  （3）用链表实现：使用递归遍历来进行有序插入。也使用了一个哨兵结点，其值大于所有实际的值。一旦到达哨兵结点，就表示到达链表末尾。

class IntSetList{private:int n;struct node{int val;node *next;node(int v,node *p){ val=v; next=p; }};node *head,*sentinel;//有序链表的插入，p表示当前遍历到的结点node *rinsert(node *p,int t){ if(p->val<t){p->next=rinsert(p->next,t); //遍历链表，找到插入位置}else if(p->val>t){p=new node(t,p);n++;}return p;}public:IntSetList(int maxelms,int maxval){sentinel=head=new node(maxval,0);n=0;}int size(){ return n; }void insert(int t){ head=rinsert(head,t); }void report(int *v){int j=0;for(node *p=head;p!=sentinel;p=p->next)v[j++]=p->val;}};

  （4）用二叉树实现：这里用二分搜索树来实现，它是有序的二叉树。将集合元素按序写入数组时使用了中序遍历。为简便，这里没有使用平衡二叉树。平衡二叉树的主要优点就是能确保在最坏情况下也有较好的性能。二叉树的插入时间效率最高，为O(logn)。

class IntSetBST{private:int n,*v,vn;struct node{int val;node *left,*right;node(int v){ val=v; left=right=0; }};node *root;//二分搜索树的插入，p表示当前遍历到的结点node *rinsert(node *p,int t){if(p==0){p=new node(t);n++;}else if(t<p->val){p->left=rinsert(p->left,t);}else if(t>p->val){p->right=rinsert(p->right,t);} //do nothing if p->val==treturn p;}void traverse(node *p){ //中序遍历：产生有序输出，并写入到向量中if(p==0)return;traverse(p->left);v[vn++]=p->val;traverse(p->right);}public:IntSetBST(int maxelms,int maxval){ root=0; n=0; }int size(){ return n;}void insert(int t){ root=rinsert(root,t); }void report(int *x){v=x; vn=0; traverse(root); }};

  （5）用位图实现：位图的优点就是使用移位运算，效率非常高。缺点是当n非常大时，位图会变得很大，占用大量的内存空间，这是一种空间换时间的策略。

class IntSetBitVec{private:enum{ BITSPERWORD=32,SHIFT=5,MASK=0x1F };int n,hi,*x;void set(int i){ x[i>>SHIFT] |= (1<<(i & MASK)); }void clr(int i){ x[i>>SHIFT] &= ~(1<<(i & MASK)); }void test(int i){ return x[i>>SHIFT] & (1<<(i & MASK)); }public:IntSetBitVec(int maxelms,int maxval){hi=maxval;x=new int[1+hi/BITSPERWORD]; //位向量for(int i=0;i<hi;i++) //初始化所有的位clr(i);n=0;}int size(){ return n; }void insert(int t){if(test(t))return;set(t);n++;}void report(int *v){int j=0;for(int i=0;i<hi;i++)if(test(i))v[j++]=i;}};

  （6）使用散列表来实现：箱是一种散列表结构，它结合了链表和位向量的优点。所有的箱用一个数组表示，每个箱中的所有整数用一个有序链表存储。整数t被散列到箱bin[1+maxval/bins]中，这里bins为箱的个数，maxval为充分大的数（存放在哨兵位置处）。

class IntSetBins{private:int n,bins,maxval;struct node{int val;node *next;node(int v,node *p){ val=v; next=p; }};node **bin,*sentinel;node* rinsert(node *p,int t){if(p->val<t){p->next=rinsert(p->next,t);}else if(p->val>t){p=new node(t,p);n++;}return p;}public:IntSetBins(int maxelms,int pmaxval){bins=maxelms; //箱的个数maxval=pmaxval;bin=new node*[bins]; //为箱数组分配空间sentinel=new node(maxval,0); //为哨兵元素分配空间，并赋一个充分大的值for(int i=0;i<bins;i++)bin[i]=sentinel;n=0;}int size(){ return n; }void insert(int t){ //将整数t放入合适的箱中，每个箱为一个有序链表int i=t/(1+maxval/bins);bin[i]=rinsert(bin[i],t);}void report(int *v){int j=0;for(int i=0;i<bins;i++)for(node *p=bin[i];p!=sentinel;p=p->next)v[j++]=p->val;}};

  关键算法设计思想：线性结构（数组、链表、位图）、树形结构（二叉树、二分搜索树、平衡二叉树）、散列表结构、集合结构、递归、哨兵技术。