简单的数据结构

关于stack,queue和list的简单实现:

template <class Type>
class Stack{
public:
	Stack(int size)
		:size_(size)
	{
		ptr_ = new Type[size_];
		next_ = ptr_;
	}
	~Stack()
	{
		delete []ptr_;
		ptr_ = NULL;
	}
	void push(const Type& val);
	Type pop();
private:
	int size_;
	Type* ptr_;
	Type* next_;
};

template <class Type>
void Stack<Type>::push(const Type& val)
{
	if(next_ - ptr_ < size_)
		*next_++ = val;
	else
		throw std::overflow_error("Stack overflow.");
}

template <class Type>
Type Stack<Type>::pop()
{
	if(next_ - ptr_ > 0)
		return *(--next_);
	else
		throw std::underflow_error("Stack underflow.");
}

template <class Type>
class Queue{
public:
	Queue(int size)
		: size_(size), empty_(true)
	{
		ptr_ = new Type[size];
		next_ = ptr_;
		beg_ = ptr_;
	}
	~Queue()
	{
		delete []ptr_;
		ptr_ = NULL;
	}
	void enqueue(const Type& val);
	Type dequeue();

private:
	bool empty_;
	Type* ptr_;
	Type* beg_;
	Type* next_;
	int size_;
};

template <class Type>
void Queue<Type>::enqueue(const Type& val)
{
	if(empty_ || next_ != beg_)
	{
		*next_++ = val;
		if(next_ - ptr_ >= size_)
			next_ = ptr_;
		empty_ = false;
	}
	else
		throw std::overflow_error("Queue overflow.");
}

template <class Type>
Type Queue<Type>::dequeue()
{
	if(!empty_)
	{
		Type temp = *beg_++;
		if(beg_ - ptr_ >= size_)
			beg_ = ptr_;
		if(beg_ == next_)
			empty_ = true;
		return temp;
	}
	else
	{
		throw std::underflow_error("Queue underflow.");
	}
}
template <class Type>
class List{
public:
	List()
		: head_(NULL), ptr_(NULL)
	{
	}
	~List()
	{
		for(; head_ != NULL; head_ = head_->next_)
			delete head_;
	}
	void push_back(const Type& val);
	Type pop_front();
private:
	struct node{
		node(const Type& val, node* next)
			: val_(val), next_(next)
		{}

		Type val_;
		node* next_;
	};
	node* ptr_;
	node* head_;
};

template <class Type>
void List<Type>::push_back(const Type& val)
{
	node* p = new node(val, NULL);
	if(ptr_ == NULL)
		head_ = ptr_ = p;
	else
		ptr_->next_ = p, ptr_ = p;
}

template <class Type>
Type List<Type>::pop_front()
{
	if(head_ != NULL)
	{
		Type temp = head_->val_;
		node* p = head_;
		head_ = head_->next_;
		delete p;
		return temp;
	}
	else
		throw std::underflow_error("List underflow.");
}

需要注意的是,队列是是一个圈形,即末尾和开始是相连的.否则,队列满后,移出元素,使队列有空间继续使用,而队列不连续的话,则无法利用这个空间.当末尾和开始的位置重合而且队列不为空时,才能判断队列已满,因为当队列为空的时候,二者也是重合的.