MyQueue.h

每次插入之前需要判断一下，队列是否已满

插入一个元素后，队尾指向下一个位置，直到环形队列已满

取出元素，从队头开始取，取出一个元素，队头就指向下一个元素

队列中空出的位置，队列为又可以插入新的元素

队列的实现，C与C++有什么区别？

队列分类。。。

队列 先入先出

普通队列    环形队列

当在堆中实例化对象时，对象当中需要有默认的构造函数（参数有默认值）

出队列必须用引用。别忘了数组位置取余

环形队列示意图，弥补普通队列的缺点，可充分利用每个内存空间

普通队列缺点

队列可分为

队列是先入先出的   

数据结构是指相互之间存在一种货多种特定关系的数据元素的集合

#ifndef MYQUEUE_H
#define MYQUEUE_H
class MyQueue
{
public:
 MyQueue(int queueCapacity);
 virtual ~MyQueue();
 void ClearQueue();//清空
 bool QueueEmpty() const;
 bool QueueFull()const;
 int QueueLength()const;
 bool EnQueue(int element);
 bool DeQueue(int &element);
 void QueueTraverse();//遍历
private:
 int *m_pQueue;//队列数组指针
 int m_iQueueLen;//队列元素个数
 int m_iQueueCapacity;//队列数组容量
 int m_iHead;
 int m_iTail;
};

#endif

MyQueue::MyQueue(int queueCapacity)
{
 m_iQueueCapacity = queueCapacity;
 m_pQueue = new int[m_iQueueCapacity];
 ClearQueue();
}
MyQueue::~MyQueue()
{
 delete[]m_pQueue;
 m_pQueue = NULL;

}
void MyQueue::ClearQueue()
{
 m_iHead = 0;
 m_iTail = 0;
 m_iQueueLen = 0;

}
bool MyQueue::QueueFull() const
{
 if (m_iQueueLen == m_iQueueCapacity)
 {
  return true;
 }
 else
 {
  return false;
 }
}
bool MyQueue::QueueEmpty() const
{
 if (m_iQueueLen == 0)
 {
  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_iQueueCapacity;
  m_iQueueLen++;
  return true;
 }
}
bool MyQueue::DeQueue(int &element)
{
 if (QueueEmpty())
 {
  return false;
 }
 else
 {
  element = m_pQueue[m_iHead];
  m_iHead++;
  m_iHead %= m_iQueueCapacity;
  m_iQueueLen--;
  return true;
 }
}
void MyQueue::QueueTraverse()
{
 for (int i = m_iHead; i < m_iQueueLen+ m_iHead; i++)
 {
  cout << m_pQueue[i%m_iQueueCapacity]<<endl;
 }
}

int main()
{
 MyQueue *p = new MyQueue(20);

 p->EnQueue(10);
 p->EnQueue(12);
 p->EnQueue(14);
 p->EnQueue(16);
 p->EnQueue(18);

 p->QueueTraverse();
 cout << endl;

 int e = 0;
 p->DeQueue(e);
 cout << e <<endl;

 p->DeQueue(e);
 cout << e <<endl;
 cout << endl;

 p->QueueTraverse();
 p->ClearQueue();
 cout <<endl;
 p->EnQueue(20);
 p->EnQueue(30);
 p->QueueTraverse();

 delete p;
 p = NULL;

 system("pause");
    return 0;
}