对象的集合－－队列，使用链表来实现

1.队列是一种基于先进先出策略的集合类型（FIFO）

2.我们可以使用原始数组来完成一个队列的构造，但是我们使用链表当做队列的内部数据结构则更好，原因有两点：

i.入队 和 出队 操作所需的时间跟集合大小无关。

ii.所需空间跟集合大小成正比。

list.hpp

#ifndef LIST_HPP
#define LIST_HPP

#include <iostream>
#include <string>
using namespace std;

template <typename T>
class MyList 
{
public:
	MyList();                  //构造函数，只用把头指针置为空就行
	~MyList();
	void insert(T item);      //向链表里面插入数据,在表尾实现插入
	T deleteFirst();		      //删除头节点
	bool isEmpty();
	unsigned int size();

private:
	class Node {         //内部类，节点类。
	public:
		Node(T item) : data(item), next(NULL){}
		~Node(){}
		T data;              //数据
		Node* next;			//链接
	};

	Node* head;           //链表的头指针
	Node* last;         //链表的尾指针
};

template <typename T>
MyList<T>::MyList() : head(NULL),last(NULL)
{
}

template <typename T>
MyList<T>::~MyList(){}

template <typename T>
void MyList<T>::insert(T item)
{
	if (isEmpty())     //如果链表为空，新建一个节点，并让头指针，尾指针指向这个节点。
	{
		Node* current = new Node(item);
		head = current;
		last = current;
	}
	else              //如果链表不为空，新建一个节点，加到尾指针的后面,并让尾指针指向新建的节点。
	{
		Node* newNode = new Node(item);
		last->next = newNode;
		last = newNode;
	}
}

template <typename T>
T MyList<T>::deleteFirst()
{
	if(isEmpty())          //如果链表为空，那么输出提示信息，返回0；
	{
		cout << "The data is empty" << endl;
	}

	else
	{
		Node* deleteNode = head;
		T data = deleteNode->data;
		head = head->next;
		delete deleteNode;           //释放内存
		return data;
	}

	return 0;
}


//模版特化，针对string类型，模版这一块掌握不是很好，可以考虑去模版或者全特化
template <>
string MyList<string>::deleteFirst()
{
	string data("");
	if(isEmpty())
	{
		cout << "The data is empty" << endl;
	}

	else
	{
		Node* deleteNode = head;
		data = deleteNode->data;
		head = head->next;
		delete deleteNode;
	}

	return data;
}

//判空函数
template <typename T>
bool MyList<T>::isEmpty()
{
	return head == NULL;
}

template <typename T>
unsigned int MyList<T>::size()
{
	unsigned int size = 0;
	while(head != NULL)
	{
		size++;
		head = head->next;
	}
	return size;
}

#endif

queue.hpp

#ifndef QUEUE_HPP
#define QUEUE_HPP

#include "list.hpp"

template <typename T>
class MyQueue
{
public:
	MyQueue();
	~MyQueue(){}
	void enqueue(T item);
	T dequeue();
private:
	MyList<T> dataList;
};

template <typename T>
MyQueue<T>::MyQueue() : dataList()
{

}

template <typename T>
void MyQueue<T>::enqueue(T item)
{
	dataList.insert(item);
}

template <typename T>
T MyQueue<T>::dequeue()
{
	return dataList.deleteFirst();
}


#endif

main.cpp

#include "queue.hpp"

int main(int argc, char** argv)
{
	MyQueue<int> queue;
	int i = 0;
	while (i != 10)
	{
		queue.enqueue(i++);
	}

	for (int j = 0; j != 10; ++j)
	{
		cout << queue.dequeue() << " ";
	}
	cout << endl;

	return 0;
}