队列

************************* seqQueue.cpp *************************
#include <iostream>

template <typename T, int maxsize = 30> //设置最大容量
class SeqQueue
{
public:
	SeqQueue()
	{
		first = last = 0; //初始时下标重叠
		cursize = 0;
	}
	~SeqQueue()
	{
		clear();
	}
	void clear()
	{
		while(!isEmpty())
		{
			dequeue();
		}
	}
	bool isEmpty()
	{
		return cursize == 0;
	}
	bool isFull() //检查队列是否已满,防止意外的覆盖
	{
		return cursize == maxsize;
	}
	void enqueue(const T& el)
	{
		if(!isFull())
		{
			storage[last] = el;            //存入元素
			last = ( last + 1 ) % maxsize; //下标后移
			cursize++;                     //计数加一
		}
		else
		{
			throw("Full Queue \n");
		}
	}
	T dequeue()
	{
		T tmp;
		if(!isEmpty())
		{
			tmp = storage[first];
			first = ( first + 1 ) % maxsize; //下标后移，此数据之后将被覆盖
			cursize--;
		}
		else
		{
			throw("Empty Queue \n");
		}
		return tmp;
	}
	T firstEl()
	{
		T tmp;
		if(!isEmpty())
		{
			tmp = storage[first];
		}
		else
		{
			throw("Empty Queue \n");
		}
		return tmp;
	}
private:
	T storage [maxsize];
	int cursize;     //当前元素个数
	int first, last; //首尾元素下标（last下标其实指向最后一个元素的下一个位置）
};

************************* linkQueue.cpp *************************
#include <iostream>
#include <list>

template <typename T>
class linkQueue
{
public:
	linkQueue(){}
	~linkQueue()
	{
		clear();
	}
	void clear()
	{
		lst.clear();
	}
	bool isEmpty()
	{
		return lst.empty();
	}
	void enqueue(const T& el)
	{
		lst.push_back(el);
	}
	T dequeue()
	{
		T tmp = lst.front(); //front():返回链表第一个节点
		lst.pop_front();     //pop_front():删除第一个节点
		return tmp;
	}
	T firstEl()
	{
		return lst.front();
	}
private:
	list<T> lst;
};

************************* listQueue.cpp *************************
#include <iostream>

template <typename T>
typedef struct QueueNode
{
	T value;
	QueueNode *next;
}node;

template <typename T>
class ListQueue
{
public:
	ListQueue()
	{
		head = tail = NULL;
	}
	~ListQueue()
	{
		clear();
	}
	void clear();
	bool isEmpty();
	void enqueue(const T& el);
	T dequeue();
	T firstEl();
private:
	node *head, *tail; //使用两个指针指向首尾节点
};

template <typename T>
void QueueNode<T>::clear()
{
	while(!isEmpty())
	{
		dequeue();
	}
}

template <typename T>
bool QueueNode<T>::isEmpty()
{
	return ( head == tail && head == NULL );
}

template <typename T>
void QueueNode<T>::enqueue(const T& el)
{
	node *pNew = new node(); //动态生成
	pNew->value = el;
	pNew->next = NULL;
	
	if(isEmpty())
	{
		head = tail = pNew;
	}
	else
	{
		tail->next = pNew;
		tail = pNew;
	}
}

template <typename T>
T QueueNode<T>::dequeue()
{
	T tmp;
	if(!isEmpty())
	{
		node *pTmp;
		if( head == tail ) //只有一个元素需特殊处理
		{
			pTmp = head;
			head = tail = NULL;
		}
		else
		{
			pTmp = head;
			head = head->next;
		}
	}
	else
	{
		throw("Empty Queue");
	}
	delete pTmp;
	return tmp;
}

template <typename T>
T QueueNode<T>::firstEl()
{
	T tmp;
	if(!isEmpty())
	{
		tmp = head->value;
	}
	else
	{
		throw("Empty Queue");
	}
	return tmp;
}