List Queue重新实现！

看标题

!

List实现：

#pragma once
#ifndef LIST_H_
#define LIST_H_

template<class Item>
class ListTP
{
private:
	enum { L_SIZE = 10 };
	struct Node
	{
	public:
		Item item;
		Node *next;
		Node *prev;
		Node(const Item & i = 0) : item(i), next(0) ,prev(0){};
	};
	Node *front;
	Node *rear;

	int items;
	const int lsize;
	ListTP(const ListTP & q) : lsize(0) {};
	ListTP & operator= (const ListTP & q) { return *this; }
public:
	ListTP(int qs = L_SIZE);
	~ListTP();
	bool isempty() const
	{
		return items == 0;
	}
	bool isfull() const
	{
		return items == lsize;
	}
	int listcount() const
	{
		return items;
	}
	bool push_back(const Item & item);
	bool push_front(const Item & item);
	bool pop_back(Item & item);
	bool pop_front(Item & item);
};
template<class Item>
inline ListTP<Item>::ListTP(int qs) :lsize(qs)
{
	front = rear = 0;
	items = 0;
}

template<class Item>
ListTP<Item>::~ListTP()
{
	Node * temp;
	while (front != 0)
	{
		temp = front;
		front = front->next;
		delete temp;
	}
}
template<class Item>
bool ListTP<Item>::push_back(const Item & item)
{
	if (isfull())
		return false;
	Node *add = new Node(item);
	items++;
	if (front == 0)
		front = add;
	else
	{
		rear->next = add;
		add->prev = rear;
	}
	rear = add;
	return true;
}
template<class Item>
bool ListTP<Item>::push_front(const Item & item)
{
	if (isfull())
		return false;
	Node *add = new Node(item);
	items++;
	if (front == 0)
		front = add;
	else
	{
		add->next = front;
		front->prev = add;
	}
	front = add;
	return true;
}
template<class Item>
bool ListTP<Item>::pop_back(Item & item)
{
	if (front == 0)
		return false;
	item = rear->item;
	items--;
	Node *temp = rear;
	rear = rear->prev;
	delete temp;
	if (items == 0)
		front = 0;
	return true;
}
template<class Item>
bool ListTP<Item>::pop_front(Item & item)
{
	if (front == 0)
		return false;
	item = front->item;
	items--;
	Node *temp = front;
	front = front->next;
	delete temp;
	if (items == 0)
		rear = 0;
	return true;
}
#endif // !LIST_H_

Queue实现:

#pragma once
#ifndef QUEUETP_H_
#define QUEUETP_H_

template<class Item>
class QueueTP
{
private:
	enum { Q_SIZE = 10 };
	struct Node
	{
	public:
		Item item;
		Node *next;
		Node(const Item & i = 0) :item(i), next(0) {};
	};
	Node * front;
	Node * rear;
	int items;     //当前容量
	const int qsize;    //最大容量
	QueueTP(const QueueTP & q) : qsize(0) {};
	QueueTP & operator= (const QueueTP & q) { return *this; }
public:
	QueueTP(int qs = Q_SIZE);
	~QueueTP();
	bool isempty() const
	{
		return items == 0;
	}
	bool isfull() const
	{
		return items == qsize;
	}
	int queuecount() const
	{
		return items;
	}
	bool enqueue(const Item &item);   //从尾添加元素
	bool dequeue(Item & item);        //从头删除元素
};

template<class Item>
QueueTP<Item>::QueueTP(int qs) : qsize(qs)
{
	front = rear = 0;
	items = 0;
}

template<class Item>
QueueTP<Item> ::~QueueTP()
{
	Node * temp;
	while (front != 0)
	{
		temp = front;
		front = front->next;
		delete temp;
	}
}

template<class Item>
inline bool QueueTP<Item>::enqueue(const Item & item)
{
	if (isfull())
		return false;
	Node * add = new Node(item);
	items++;
	if (front == 0)
		front = add;
	else
		rear->next = add;
	rear = add;
	return true;
}

template<class Item>
bool QueueTP<Item>::dequeue(Item & item)
{
	if (front == 0)
		return false;
	item = front->item;
	items--;
	Node *temp = front;
	front = front->next;
	delete temp;
	if (items == 0)
		rear = 0;
	return true;
}
#endif