《编程珠玑》第13章算法的简单C语言实现

//链表
class IntSetList
{
public:
	IntSetList(int maxelements, int maxval){
		sentinel = head = new node(maxval, NULL);
		n = 0;
	}
private:
	int n;
	struct node{
		int val;
		node *next;
		node(int v, node *p) { val = v; next = p; }
	};

	node *head;
	node *sentinel;

public:
	int size(){
		return n;
	}
	void report(int *v)
	{
		int j = 0;
		for (node *p = head; p != sentinel; p = p->next)
			v[j++] = p->val;
	}
	void insert(int t)
	{
		head = rinsert(head, t);
	}
	node *rinsert(node *p, int t);
};

IntSetList::node *IntSetList::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;
}

/*********************************************************************************************************/

//二分搜索树
class IntSetBST
{
private:
	struct node{
		int val;
		node *left, *right;
		node(int i){
			val = i; left = right = NULL;
		}
	};
public:
	IntSetBST(int maxelemnts, int maxval){
		root = NULL;
		n = 0;
	}
	int size(){
		return n;
	}
	void insert(int t){
		root = rinsert(root, t);
	}
	void report(int *x){
		v = x;
		vn = 0;
		traverse(root);
	}
private:
	node *rinsert(node *p, int t);
	void traverse(node *p);
private:
	int n;
	int *v;
	int vn;
	node *root;
};

IntSetBST::node * IntSetBST::rinsert(node *p, int t)
{
	if (p == NULL)
	{
		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);
	}

	return p;
}

void IntSetBST::traverse(node *p)
{
	if (p == NULL)
		return;
	traverse(p->left);
	v[vn++] = p->val;
	traverse(p->right);
}

/*********************************************************************************************************/
//位向量
class IntSetBitVec
{
private:
	enum{ 
		BITSPERWORD = 32,
		SHIFT = 5,
		MASK = 0x1F,
	};
public:
	IntSetBitVec(int maxelements, 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 report(int *v){
		int j = 0;
		for (int i = 0; i <= hi; i++){
			if (test(i))
				v[j++] = i;
		}
	}

	void insert(int t){
		if (test(t))
			return;
		set(t);
		n++;
	}
private:
	void set(int i){
		x[i >> SHIFT] |= (1 << ( i & MASK));
	}
	void clr(int i){
		x[i >> SHIFT] &= ~(1 << (i & MASK));
	}
	int test(int i){
		return x[i >> SHIFT] & (1 << (i & MASK));
	}
private:
	int n;
	int hi;
	int *x;
};

/*********************************************************************************************************/
//箱
class IntSetBins{
private:
	struct node{
		int val;
		node *next;
		node(int v, node *p){
			val = v;
			next = p;
		}
	};
public:
	IntSetBins(int maxelements, int pmaxval){
		bins = maxelements;
		maxval = pmaxval;
		bin = new node*[bins];
		sentinel = new node(maxval, NULL);

		for (int i = 0; i < bins; i++){
			bin[i] = sentinel;
		}

		n = 0;
	}

	int size(){
		return n;
	}
	void insert(int t){
		int i = t / (maxval/bins+1);
		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;
		}
	}
private:
	node * rinsert(node *p, int t);
private:
	int n;
	int bins;
	int maxval;
	node **bin;
	node *sentinel;
};

IntSetBins::node * IntSetBins::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;
}

int main()
{
/*	IntSetList il(10, 100);
	il.insert(5);
	il.insert(50);
	il.insert(10);
	il.insert(1);
	int v[10];
	il.report(v);
	for (int i = 0; i < il.size(); i++)
	{
		cout << v[i] << endl;
	}
	*/
	/*
	IntSetBST ib(10, 100);
	ib.insert(5);
	ib.insert(50);
	ib.insert(10);
	ib.insert(1);
	int v[10];
	ib.report(v);
	for (int i = 0; i < ib.size(); i++)
	{
		cout << v[i] << endl;
	}
	*/
	/*
	IntSetBitVec iv(10, 100);
	iv.insert(5);
	iv.insert(50);
	iv.insert(10);
	iv.insert(1);
	int v[10];
	iv.report(v);
	for (int i = 0; i < iv.size(); i++)
	{
		cout << v[i] << endl;
	}
	*/
	IntSetBins ib(10, 100);
	ib.insert(5);
	ib.insert(50);
	ib.insert(10);
	ib.insert(1);
	int v[10];
	ib.report(v);
	for (int i = 0; i < ib.size(); i++)
	{
		cout << v[i] << endl;
	}
	getchar();
	return 0;
}