算法与数据结构基础-队列

数据结构 相互存在一种或多种特定 关系的数据元素集合

队列 只允许在一端进行插入，另一端进行删除的运算受限的线性表，先入先出（FIFO），队列头和队列尾
顺序队列：地址连续的存储单元来依次存放当前队列的元素，队列头尾指针前后移动，效率较低
环形队列：每处理一个，队列头指针移动，另一个队列尾跟上，效率更高

队列实现

class MyQueue
{
public:
	MyQueue(int queueCapacity);	//InitQueue（&Q）创建队列
	virtual ~MyQueue();			//DestroyQueue(&Q)销毁队列
	void ClearQueue();			//清空队列
	bool QueueEmpty()const;		//判空队列
	bool QueueFull()const;		//判满队列
	int QueueLength()const;		//队列长度
	bool EnQueue(Customer element);	//新元素入队
	bool DeQueue(Customer &element);	//首元素出队
	void QueueTraverse();		//遍历队列
private:
	int *m_pQueue;				//队列数组指针，可为任意类型，用于存储不同数据
	int m_iQueueLen;			//队列元素个数
	int m_iQqueueCapacity;		//队列数组容量
	int m_iHead;				//队列头
	int m_iTail;				//队列尾
};

MyQueue::MyQueue(int queueCapacity)
{
	m_iQqueueCapacity = queueCapacity;
	m_iHead = 0;
	m_iTail = 0;
	m_iQueueLen = 0;
	m_pQueue = new Customer[m_iQqueueCapacity];//申请长度为容积的内存
}

MyQueue::~MyQueue()
{
	delete[] m_pQueue;
	m_pQueue = NULL;
}
void MyQueue::ClearQueue()
{
	m_iHead = 0;
	m_iTail = 0;
	m_iQueueLen = 0;
}

bool MyQueue::QueueEmpty()const
{
	if (m_iQueueLen == 0)//长度为0
		return true;
	else
		return false;
	// return m_iQueueLen==0?true:false
}

bool MyQueue::QueueFull()const
{
	if (m_iQueueLen == m_iQqueueCapacity)//长度为容积
		return true;
	else
		return false;
}

int MyQueue::QueueLength()const
{
	return m_iQueueLen;
}

bool MyQueue::EnQueue(int element)//队列尾加入新元素
{
	if (QueueFull())
		return false;
	else
	{
		m_pQueue[m_iTail] = element;//参数赋值给队列尾
		m_iTail++;
		m_iTail = m_iTail%m_iQqueueCapacity;//保证m_iTail不会超过容积
		m_iQueueLen++;
		return true;
	}
}

bool MyQueue::DeQueue(int &element)//队列头提出
{
	if (QueueEmpty())
		return false;
	element = m_pQueue[m_iHead];//队列头给引用参数赋值
	m_iHead++;
	m_iHead = m_iHead%m_iQqueueCapacity;//保证m_iHead不会超过容积
	m_iQueueLen--;
	return true;

}

void MyQueue::QueueTraverse()
{
	for (int i = m_iHead; i < m_iQueueLen+ m_iHead; i++)//队列长+队列头，保证循环次数
	{
		cout<<m_pQueue[i%m_iQqueueCapacity];//i与容积求余，保证i在容积反围内
	}
}

队列可以用于存储任意数据类型，只要修改队列数组的指针和插入提取函数的参数类型。
或者使用模板类，直接使队列可用于任意类型。