学习循环队列-数组实现

本文章的图和代码来绝大部分自清华大学数据结构第二版，这是一篇学习笔记。

1. 判断队列是否为空：return (front==rear)?true:false;
2. 判断队列是否满：    return ((rear+1)%maxSize==front)?true:false; (maxSize为数组长度)
3. 队尾插入一个元素：rear=(rear+1)%maxSize;
4. 队列头弹出一个元素：front=(front+1)%maxSize;
5. 队列长度： (rear-front+maxSize)%maxSize;

Queue.h

#ifndef Queue_h
#define Queue_h
const int size = 100;

template <class T>
class Queue
{
public:
    Queue(){};
    ~Queue(){};
    virtual bool push(const T&x)=0;         //新元素x入栈
    virtual bool pop(T& x)=0;               //队头元素出队列
    virtual bool getFront(T& x)=0;          //读取队头元素的值
    virtual bool isEmpty()const = 0;        //判断队列是否为空
    virtual bool isFull()const =0;          //判断队列是否满
    virtual int getSize()const =0;          //求队列元素个数
};

#endif /* Queue_h */

Queue.cpp

#include "Queue.h"
#include <iostream>
using namespace std;

template <class T>
class SeqQueue:public Queue<T>
{
protected:
    int front,rear;
    T* elements;
    int maxSize;
public:
    SeqQueue(int size):front(0),rear(0),maxSize(size){elements = new T(size);}
    ~SeqQueue(){delete []elements;}
    bool isEmpty()const{return (front==rear)?true:false;}
    bool isFull()const{return ((rear+1)%maxSize==front)?true:false;}
    bool push(const T& x);
    bool pop(T& x);
    bool getFront(T& x);
    void makeEmpty(){front=rear=0;}
    void overflow();        //溢出处理
    int getSize()const;
    friend ostream& operator<<(ostream& out,SeqQueue<T>& s);
};
template <class T>
bool SeqQueue<T>::push(const T& x)
{
    if (isFull()) overflow();
    elements[rear]=x;
    rear=(rear+1)%maxSize;
    return true;
}
template <class T>
bool SeqQueue<T>::pop(T& x)
{
    if (isEmpty()) return false;
    x=elements[front];
    front=(front+1)%maxSize;
    return true;
}
template <class T>
bool SeqQueue<T>::getFront(T& x)
{
    if (isEmpty()) return true;
    x=elements[front];
    return true;
    
}
template <class T>
void SeqQueue<T>::overflow()    //自己写的溢出处理代码，思路：开辟一个为原来两倍的新数组，旧数组元素复制到新数组中
{
    
    T* newArray = new T(maxSize*2);
    int f=0,r=0;
    for (int i=front; i!=rear; i=(i+1)%maxSize)
    {
        newArray[r]=elements[i];
        r++;
    }
    front=f;
    rear=r;
    maxSize=maxSize*2;
    delete []elements;
    elements=newArray;
}
template <class T>
int  SeqQueue<T>::getSize()const
{
    return (rear-front+maxSize)%maxSize;
}
template <class T>
ostream& operator<<(ostream& out,SeqQueue<T>& s)
{
    for (int i=s.front; i!=s.rear; i=(i+1)%s.maxSize)
    {
        out<<s.elements[i]<<" ";
    }
    return out;
}