MyQueue.cpp

⑥bool EnQueue(int element);

⑦bool DeQueue(int& element);

⑧void QueueTraverse();

*Array

myQueue

for (int i = 0; i < m_iQueueLen; i++)
{
	cout << m_pQueue[(m_iHead + i) % m_iQueueCapacity] << endl;   // //这里的i是要与总容量取余
}

或者：
for (int i = m_iHead ; i < m_iQueueLen+m_iHead ; i++)
{
	cout << m_pQueue[ i % m_iQueueCapacity] << endl;   //这里的i是要与总容量取余
}

这里遍历是有问题的，循环应该这么写。   这里用取余符号%来解决下标超出范围的问题，很机智

环形队列三个函数：新元素入队、首元素出队、遍历队列实现：

新元素入队：先判断是否未满。 

上图错误：

未加m_iQueueLen++;

m_iTail = m_iTail % m_iQueueCapacity;

出队：出队的是队头指向的元素。出队先判断队是否为空。

下图错误：

未加m_iQueueLen—;

m_iHead= m_iHead % m_iQueueCapacity;

遍历，注意对i取余的原理。

遍历 QueueTraverse

因为是环形，所以位置应该取余。入队出队函数都要做相应更改

入队出队 长度增减

打印+   #include <iostream>

DeQueue

EnQueue:这里用的数组而非指针

QueueFull的实现

判断队列是否为满： QueueFull

#include<iostream>

using namespace std;

class Myqueue

{

public:

Myqueue(int capcaity);//初始化队列

~Myqueue();

int get_length();  //获取队列元素个数

bool judge_empty();  //判断队列是否为空

bool judge_full();  //判断队列是否为满

bool in_ele(int x);   //入栈

bool out_ele(int &x);  //出栈

void tra_ele();   //遍历

void clear_queue();  //清空

private:

int m_length;  //队列元素个数

int m_capacity;   // 队列元素容量

int m_head;   //队列首部元素编号

int m_tail;   // 队列尾部元素编号

int *my_queue;  //定义队列指针

};

Myqueue::Myqueue(int capacity)

{

m_capacity = capacity;

my_queue = new int[m_capacity];

if (my_queue == NULL)

{

cout << "the applicatiao ofstorage for my_queue is failed" << endl;

}

m_head = 0;

m_tail = 0;

m_length = 0;

}

Myqueue::~Myqueue()

{

delete[]my_queue;

my_queue = NULL;

}

int Myqueue::get_length()

{

return m_length;

}

bool Myqueue::judge_empty()

{

if (m_length == 0)

{

cout << "the queue is empty" << endl;

return true;

}

return false;

}

bool Myqueue::judge_full()

{

if (m_length == m_capacity)

{

cout << "the queue is full"<<endl;

return true; 

}

return false;

}

bool Myqueue::in_ele(int x)

{

if (judge_full())

{

return false;

}

my_queue[m_tail] = x;

m_tail++;

m_length++;

if (m_tail == m_capacity)

m_tail = 0;

return true;

}

bool Myqueue::out_ele(int &x)

{

if (judge_empty())

{

return false;

}

x = my_queue[m_head];

m_head++;

m_length=m_length-1;

if (m_head == m_capacity)

m_head = 0;

return true;

}

void Myqueue::tra_ele()

{

int num = m_head;

for (int i = m_head; i<m_head+m_length; i++)

{

if (num == m_capacity)

{

num = 0;

   }

cout << my_queue[num] << endl;

num++;

}

}

void Myqueue::clear_queue()

{

m_head = 0;

m_tail = 0;

m_length = 0;

}

int main()

{

int out_ele;

Myqueue *lis =new Myqueue(5);

lis->in_ele(11);

lis->in_ele(12);

lis->in_ele(14);

lis->in_ele(8);

lis->in_ele(20);

lis->tra_ele();

cout << endl;

lis->out_ele(out_ele);

lis->tra_ele();

cout << endl;

lis->out_ele(out_ele);

lis->tra_ele();

cout << endl;

lis->in_ele(14);

lis->in_ele(8);

lis->tra_ele();

cout << endl;

lis->in_ele(20);

return 0;

}

1.每次队列插入一个新元素，队列长度应该+1。m_iQueueLen++;

   每次队列取出一个元素    ，队列长度应该-1。m_iQueueLne--;

2.对于环形队列，经过一圈后又从0开始（因此要求 模%）：

    入队:m_ ihead =m_ ihead %m_ iQueuecapacity;

    出队:m_itail   = m_i tail   %m_iQueuecapacity;

    遍历队列时，是从队头开始遍历的，而有时候队头不是指向位置0，指向其他位置 。另外，对于环形队列，当遍历完一圈后又从0开始。

 for(int i = 0; i <  m_iQueueLen; ++i)

        cout << m_pQueue[(i+m_iHead)%m_iQueueCapacity] << endl;

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

#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;
}

1.环形队列入队 head++; head = head % capacity; 2.环形队列出队 tail++; tail = tail % capacity; 3.遍历环形队列时要注意循环变量应初始化为队首指针所指向的数组下标，输出时要对循环变量进行求余操作(i % capacity)以防数组下标越界问题的发生 for(int i = head; i < length + head; i++)  cout<<QueueData[i % capacity]<<"  ";