红黑树源码

//红黑树的大部分代码摘自《算法导论》

class rset_i<T>
{
	T key;
	rset_i<T>* father;
	rset_i<T>* left;
	rset_i<T>* right;
	int col;//1 is red,0 is black
};

class rset<T>
{
	rset_i<T>* m_root;
	rset_i<T> m_nil;
	int m_count;

	~rset<T>()
	{
		clear();
	}

	rset<T>()
	{
		init();
	}
	
	rset<T>(rset<T>& a)
	{
		init();
		for p=a.begin;p!=a.end;p=next(p)
			insert(*p)
	}
	
	rset<T>(rset<T> a)
	{
		init();
		for p=a.begin;p!=a.end;p=next(p)
			insert(*p)
	}
	
	operator=(rset<T>& a)
	{
		clear();
		for p=a.begin;p!=a.end;p=a.next(p)
			insert(*p)
	}
	
	T& operator[](int n)
	{
		T* p=index(n);
		return *p;
	}

	void init()
	{
		m_nil.father=&m_nil;
		m_nil.left=&m_nil;
		m_nil.right=&m_nil;
		m_nil.col=0;

		m_root=&m_nil;
		m_count=0;
	}

	void clear()
	{
		clear_x(m_root);
		init();
	}

	void clear_x(rset_i<T>* x)
	{
		if (x==&m_nil)
		{
			return;
		}
		clear_x(x->left);
		clear_x(x->right);
		r_delete<rset_i<T>> x;
	}

	rbool empty()
	{
		return m_count==0;
	}

	int count()
	{
		return m_count;
	}

	void left_rotate(rset_i<T>* x)
	{
		rset_i<T>* y;
		if (x->right==&m_nil)
		{
			return;
		}
		y=x->right;
		x->right=y->left;
		y->left->father=x;
		y->father=x->father;
		if (x->father==&m_nil)
		{
			m_root=y;
		}
		elif(x->father->left==x)
		{
			x->father->left=y;
		}
		else
		{
			x->father->right=y;
		}
		y->left=x;
		x->father=y;
	}

	void right_rotate(rset_i<T>* x)
	{
		rset_i<T>* y;
		if (x->left==&m_nil)
		{
			return;
		}
		y=x->left;
		x->left=y->right;
		y->right->father=x;
		y->father=x->father;
		if (x->father==&m_nil)
		{
			m_root=y;
		}
		elif(x->father->left==x)
		{
			x->father->left=y;
		}
		else
		{
			x->father->right=y;
		}
		y->right=x;
		x->father=y;
	}

	void insert_fixup(rset_i<T>* z)
	{
		rset_i<T>* y;
		while(z->father->col==1) 
		{ 
			if(z->father==z->father->father->left) 
			{ 
				y=z->father->father->right; 
				if(y->col==1) 
				{ 
					z->father->col=0; 
					y->col=0; 
					z->father->father->col=1; 
					z=z->father->father; 
				} 
				else 
				{  
					if(z==z->father->right) 
					{ 
						z=z->father; 
						left_rotate(z); 
					} 
					z->father->col=0; 
					z->father->father->col=1; 
					right_rotate(z->father->father); 
				} 
			} 
			else 
			{ 
				y=z->father->father->left; 
				if(y->col==1) 
				{ 
					z->father->col=0; 
					y->col=0; 
					z->father->father->col=1; 
					z=z->father->father; 
				} 
				else 
				{  
					if(z==z->father->left) 
					{ 
						z=z->father; 
						right_rotate(z); 
					} 
					z->father->col=0; 
					z->father->father->col=1; 
					left_rotate(z->father->father); 
				} 
			} 
		} 
		m_root->col=0; 
	}

	void insert_p(rset_i<T>* z)
	{
		rset_i<T>* y;
		rset_i<T>* x;
		y=&m_nil;
		x=m_root;
		while(x!=&m_nil)
		{
			y=x;
			if (z->key<x->key)
			{
				x=x->left;
			}
			else
			{
				x=x->right;
			}
		}
		z->father=y;
		if (y==&m_nil)
		{
			m_root=z;
		}
		elif(z->key<y->key)
		{
			y->left=z;
		}
		else
		{
			y->right=z;
		}
		z->left=&m_nil;
		z->right=&m_nil;
		z->col=1;
		insert_fixup(z);
	}

	void insert(const T& a)
	{
		rset_i<T>* p=r_new<rset_i<T>>(1)
		p->key=a;
		insert_p(p);
		m_count++;
	}
	
	void insert(T a)
	{
		rset_i<T>* p=r_new<rset_i<T>>(1)
		p->key=a;
		insert_p(p);
		m_count++;
	}

	void insert_c(const T& a)
	{
		if (exist(a))
		{
			return;
		}
		insert(a);
	}
	
	void insert_c(T a)
	{
		if (exist(a))
		{
			return;
		}
		insert(a);
	}

	void test(rset_i<T>* z)
	{
		if (z!=&m_nil)
		{
			test(z->left);
			z->key.printl();
			test(z->right);
		}
	}

	void erase_fixup(rset_i<T>* x)
	{
		rset_i<T>* w;
		while(x!=m_root&&x->col==0)
		{
			if (x==x->father->left)
			{
				w=x->father->right;
				if (w->col==1)
				{
					w->col=0;
					x->father->col=1;
					left_rotate(x->father);
					w=x->father->right;
				}
				if (w->left->col==0&&w->right->col==0)
				{
					w->col=1;
					x=x->father;
				}
				else
				{
					if(w->right->col==0)
					{
						w->left->col=0;
						w->col=1;
						right_rotate(w);
						w=x->father->right;
					}
					w->col=x->father->col;
					x->father->col=0;
					w->right->col=0;
					left_rotate(x->father);
					x=m_root;
				}
			}
			else
			{
				w=x->father->left;
				if (w->col==1)
				{
					w->col=0;
					x->father->col=1;
					right_rotate(x->father);
					w=x->father->left;
				}
				if (w->right->col==0&&w->left->col==0)
				{
					w->col=1;
					x=x->father;
				}
				else
				{
					if(w->left->col==0)
					{
						w->right->col=0;
						w->col=1;
						left_rotate(w);
						w=x->father->left;
					}
					w->col=x->father->col;
					x->father->col=0;
					w->left->col=0;
					right_rotate(x->father);
					x=m_root;
				}
			}
		}
		x->col=0;
	}

	rset_i<T>* erase_p(rset_i<T>* z)
	{
		rset_i<T>* y;
		rset_i<T>* x;
		if (z->left==&m_nil||z->right==&m_nil)
		{
			y=z;
		}
		else
		{
			y=successor(z);
		}
		if (y->left!=&m_nil)
		{
			x=y->left;
		}
		else
		{
			x=y->right;
		}
		x->father=y->father;
		if (y->father==&m_nil)
		{
			m_root=x;
		}
		elif(y==y->father->left)
		{
			y->father->left=x;
		}
		else
		{
			y->father->right=x;
		}
		if (y!=z)
		{
			z->key=y->key;
		}
		if (y->col==0)
		{
			erase_fixup(x);
		}
		return y;
	}

	void erase(const T& a)
	{
		rset_i<T>* x=search(m_root,a);
		if (x!=&m_nil)
		{
			x=erase_p(x);
			r_delete<rset_i<T>>x
			m_count--;
		}
	}
	
	void erase(T a)
	{
		rset_i<T>* x=search(m_root,a);
		if (x!=&m_nil)
		{
			x=erase_p(x);
			r_delete<rset_i<T>>x
			m_count--;
		}
	}

	bool exist(const T& a)
	{
		return search(m_root,a)!=&m_nil;
	}

	rset_i<T>* successor(rset_i<T>* x)
	{
		rset_i<T>* y;
		if (x->right!=&m_nil)
		{
			return minimum(x->right);
		}
		y=x->father;
		while(y!=&m_nil&&x==y->right)
		{
			x=y;
			y=y->father;
		}
		return y;
	}

	rset_i<T>* predecessor(rset_i<T>* x)
	{
		rset_i<T>* y;
		if (x->left!=&m_nil)
		{
			return maximum(x->left);
		}
		y=x->father;
		while(y!=&m_nil&&x==y->left)
		{
			x=y;
			y=y->father;
		}
		return y;
	}

	rset_i<T>* minimum(rset_i<T>* x)
	{
		while(x->left!=&m_nil)
		{
			x=x->left;
		}
		return x;
	}

	rset_i<T>* maximum(rset_i<T>* x)
	{
		while(x->right!=&m_nil)
		{
			x=x->right;
		}
		return x;
	}

	rset_i<T>* search(rset_i<T>* x,const T& a)
	{
		while(x!=&m_nil&&a!=x->key)
		{
			if (a<x->key)
			{
				x=x->left;
			}
			else
			{
				x=x->right;
			}
		}
		return x;
	}

	T* find(const T& a)
	{
		rset_i<T>* x=search(m_root,a);
		if (x==&m_nil)
		{
			return NULL;
		}
		return r_to<T*,rset_i<T>*>x;
	}

	T* next(void* p)
	{
		rset_i<T>* x=successor(r_to<rset_i<T>*,void*>(p));
		if (x==&m_nil)
		{
			return NULL;
		}
		return r_to<T*,rset_i<T>*>x;
	}
	
	T* prev(void* p)
	{
		rset_i<T>* x=predecessor(r_to<rset_i<T>*,void*>(p));
		if (x==&m_nil)
		{
			return NULL;
		}
		return r_to<T*,rset_i<T>*>x;
	}

	T* begin()
	{
		rset_i<T>* x=minimum(m_root);
		if (x==&m_nil)
		{
			return NULL;
		}
		return r_to<T*,rset_i<T>*>x;
	}

	T* end()
	{
		return null;
	}

	T* index(int n)
	{
		T* p=begin();
		for (;n;n--)
		{
			if (p==NULL)
			{
				return null;
			}
			p=next(p);
		}
		return p;
	}
};