循环队列

circular queue

#include<iostream>

using namespace std;
#define MAXSIZE 10

template<typename T>
class SeqQueue
{
public:
    SeqQueue();                 //构造函数
    ~SeqQueue();                //析构函数

public:
    bool EnQueue(const T& e);   //入队
    bool DeQueue(T& e);         //出队列
    bool GetHead(T& e);         //读取队头元素
    void ClearQueue();          //将队列清空

    void DispList();            //输出顺序队列中的所有元素
    int ListLength();           //获取队列长度

    bool IsEmpty();             //判断数据队列是否为空
    bool IsFull();

private:
    T* m_data;                  //存放顺序队列中的元素
    int m_front;                //队头指针，允许删除的一端，如果队列不为空，则指向队头元素
    int m_rear;                 //队尾指针，允许插入的一端，如果队列不为空，则指向队尾元素下一个位置
};


//构造函数
template<typename T>
SeqQueue<T>::SeqQueue()
{
    m_data = new T[MAXSIZE];     //动态分配内存

    //空队列约定 m_front 和 m_rear 都为 0
    m_front = 0;
    m_rear = 0;
}

template<typename T>
SeqQueue<T>::~SeqQueue()
{
    delete [] m_data;
}

//入队列（增加数据）
template<typename T>
bool SeqQueue<T>::EnQueue(const T& e)
{
    if(IsFull() == true)
    {
        cout << "顺序队列以满，不能在进行入队操作了" << endl;
        return false;
    }

    m_data[m_rear] = e;     //将数据放入队尾
    //m_rear++;               //队尾指针向后走，
    m_rear = (m_rear + 1) % MAXSIZE;     //队尾指针加1取余，这样m_data的标就控制在0 ~ MAXSIZE - 1之间
    return true;
}

//出队列
template<typename T>
bool SeqQueue<T>::DeQueue(T& e)
{
    if(IsEmpty() == true)
    {
        cout << "顺序队列为空，不能出队操作了" << endl;
        return false;
    }
    e = m_data[m_front];    //队头元素值返回到e中
    //m_front++;
    m_front = (m_front + 1) % MAXSIZE;
    return true;
}

template<typename T>
bool SeqQueue<T>::GetHead(T& e)
{
    if(IsEmpty() == true)
    {
        cout << "顺序队列为空，不能进行读取队头元素" << endl;
        return false;
    }
    e = m_data[m_front];
    return true;
}

//输出顺序队列中所有元素,
template<typename T>
void SeqQueue<T>::DispList()
{
    //按照从队头到队尾的顺序来显示数据
    for(int i = m_front; i != m_rear;)
    {
        cout << m_data[i] << " ";      //每个数据之间以空格分隔
        i = (i + 1) % MAXSIZE;
    }
    cout << endl;
}

//获取顺序队列的长度
template<typename T>
int SeqQueue<T>::ListLength()
{
    return (m_rear + MAXSIZE - m_front) % MAXSIZE;
}

//判断顺序队列是否为空
template<typename T>
bool SeqQueue<T>::IsEmpty()
{
    if(m_front == m_rear)
    {
        return true;
    }
    return false;
}

template<typename T>
bool SeqQueue<T>::IsFull()
{
    if((m_rear + 1) % MAXSIZE == m_front)
    {
        return true;
    }
    return false;
}

//将队列清空
template<typename T>
void SeqQueue<T>::ClearQueue()
{
    m_rear = m_front = 0;
}
int main()
{
    SeqQueue<int> queue;
    queue.EnQueue(150);
    queue.EnQueue(200);
    queue.EnQueue(300);
    queue.EnQueue(400);

    queue.DispList();

    cout << "-------------" << endl;
    int temp;
    queue.DeQueue(temp);
    queue.DeQueue(temp);
    queue.DeQueue(temp);
    queue.DeQueue(temp);
    queue.DeQueue(temp);
    queue.DispList();

    cout << "-------------" << endl;
    queue.EnQueue(400);
    queue.EnQueue(500);
    queue.EnQueue(600);
    queue.EnQueue(700);
    queue.EnQueue(800);
    queue.EnQueue(800);
    queue.EnQueue(800);
    queue.EnQueue(800);
    queue.EnQueue(800);
    queue.EnQueue(800);
    queue.DispList();

    cout << "队列的长度为 " << queue.ListLength() << endl;
    return 0;
}

//循环队列
    //a) 队列满的判断条件 (m_rear + 1) % MAXSIZE == m_front;
    //b) 队列为空的判断条件 m_rear = m_front;