编程珠玑Column13中5种实现整型集合（IntSet）的方式

首先构造公共基类，因为包含纯虚函数，所以是虚基类

#pragma once

class IntSet{
public:
    virtual int size()=0;
    virtual void report(int *v)=0;
    virtual void insert(int t)=0;
};

基于数组的实现：

#include "IntSet.h"

class IntSetArray:public IntSet{
    int n,*x;
public:
    IntSetArray(int size,int max):n(0),x(new int[size+1])//!!!size+1
    {
        x[0]=max;
    }
    ~IntSetArray(){delete []x;}
    int size(){return n;}
    void insert(int t)
    {
        int i=-1;
        while(t>x[++i]){}
        if(t==x[i])
            return;
        /*t<x[i]*/
        for(int j=n;j>=i;--j)
            x[j+1]=x[j];
        x[i]=t;
        ++n;//!!! ++n
    }
    void report(int *v)
    {
        for(int i=0;i<n;++i)
            v[i]=x[i];
    }
};

基于链表的实现：

#include "IntSet.h"

class IntSetList:public IntSet{
    struct node{
        int val;
        node *next;
        node(int val,node *next):val(val),next(next){}
    };
    int n;
    node *sentinel,*head;
    node *rinsert(node *p,int t)
    {
        if(t>p->val)
            p->next=rinsert(p->next,t);
        else if(t<p->val)
        {
            p=new node(t,p);
            ++n;
        }
        /*if t==p->val then do nothing */
        return p;
    }
    void releaseList(node *p)
    {
        if(p==sentinel)
            return;
        releaseList(p->next);
        delete p;
    }
public:
    IntSetList(int size,int max):n(0),sentinel(new node(max,0)),head(sentinel){}//***
    ~IntSetList()//递归释放空间
    {
        releaseList(head);
        delete sentinel;
    }
    int size(){return n;}
    void insert(int t)
    {
        head=rinsert(head,t);
    }
    void report(int *v)
    {
        int i=0;
        for(node *p=head;p!=sentinel;p=p->next)
            v[i++]=p->val;
    }
};

基于二叉查找树（BST）的实现：

#include "IntSet.h"

class IntSetBST:public IntSet{
    int n,vn;
    int *v;
    struct node{
        int val;
        node *left,*right;
        node(int val):val(val),left(0),right(0){}
    };
    node *root;
    node *rinsert(node *p,int t)
    {
        if(p==0)
        {
            p=new node(t);
            ++n;
        }
        if(t>p->val)
            p->right=rinsert(p->right,t);
        else if(t<p->val)
            p->left=rinsert(p->left,t);
        return p;
    }
    void traverse(node *p)//IntSetBST中v和vn的作用仅仅是为了减少traverse的参数,否则要传递int *v和int *pvn
    {
        if(p==0)//***
            return;
        traverse(p->left);
        v[vn++]=p->val;
        traverse(p->right);
    }
    void releaseBST(node *p)//后序释放
    {
        if(p==0)
            return;
        releaseBST(p->left);
        releaseBST(p->right);
        delete p;
    }
public:
    IntSetBST(int size,int max):n(0),root(0){}
    ~IntSetBST()
    {
        releaseBST(root);
    }
    int size(){return n;}
    void insert(int t)
    {
        root=rinsert(root,t);
    }
    void report(int *v)
    {
        this->v=v;
        vn=0;
        traverse(root);
    }
};

基于位向量的实现：

#include "IntSet.h"

class IntSetBitVec:public IntSet{
    enum {BITSPERWORD=32,SHIFT=5,MASK=0x1f};
    int n,*vec,max;
    void set(int i){vec[i>>SHIFT]|=1<<(i&MASK);}
    void clr(int i){vec[i>>SHIFT]&=~1<<(i&MASK);}
    bool test(int i){return vec[i>>SHIFT]&1<<(i&MASK);}
public:
    IntSetBitVec(int size,int max):n(0),vec(new int[max/BITSPERWORD+1]),max(max)
    {
        for(int i=0;i<max;++i)
            clr(i);
    }
    ~IntSetBitVec()
    {
        delete []vec;
    }
    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<max;++i)
            if(test(i))
                v[j++]=i;
    }
};

基于桶（Bin）结构的实现：

#include "IntSet.h"

class IntSetBins:public IntSet{
    int n,max,Size;
    struct node{
        int val;
        node *next;
        node(int val,node *next):val(val),next(next){}
    };
    node **bins,*sentinel;
    node *rinsert(node *p,int t)
    {
        if(t>p->val)
            p->next=rinsert(p->next,t);
        else if(t<p->val)
        {
            p=new node(t,p);
            ++n;
        }
        return p;
    }
    void releaseList(node *p)
    {
        if(p==sentinel)
            return;
        releaseList(p->next);
        delete p;
    }
public:
    IntSetBins(int Size,int max):sentinel(new node(max,0)),bins(new node*[Size]),n(0),Size(Size),max(max)
    {
        for(int i=0;i<Size;++i)
            bins[i]=sentinel;
    }
    ~IntSetBins()
    {
        for(int i=0;i<Size;++i)
            releaseList(bins[i]);
        delete []bins;
        delete sentinel;
    }
    int size(){return n;}
    void insert(int t)
    {
        int i=t/(max/Size+1);
        bins[i]=rinsert(bins[i],t);
    }
    void report(int *v)
    {
        int j=0;
        for(int i=0;i<Size;++i)
            for(node *p=bins[i];p!=sentinel;p=p->next)
                v[j++]=p->val;
    }
};

测试程序源码：

#include "IntSet.h"
#include "IntSetArray.h"
#include "IntSetList.h"
#include "IntSetBST.h"
#include "IntSetBins.h"
#include "IntSetBitVec.h"
#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;
int main()
{
    int n,m;
    cin>>n>>m;
    int *v=new int[m];
    IntSet *ss[5]={new IntSetArray(m,n),new IntSetList(m,n),new IntSetBST(m,n),new IntSetBins(m,n),new IntSetBitVec(m,n)};
    srand(time(NULL));
    for(int i=0;i<5;++i)
    {
        while(ss[i]->size()<m)
            ss[i]->insert(rand()%n);
        ss[i]->report(v);
        cout<<"i:"<<i<<endl;
        for(int i=0;i<m;++i)
            cout<<v[i]<<" ";
        cout<<endl;
    }
    delete []v;
    for(int i=0;i<5;++i)//!!! not delete []ss
        delete ss[i];
    return 0;
}