设计循环队列

1.假溢出现象：实际个数变量size；循环队列

2.(队列空间大小为m时，有m-1个元素就认为是队满。这样当头尾指针的值相同时，则认为对空；当尾指针在循环意义上加1后是等于头指针，则认为队满)

当添加一个元素时,(queue.rear + 1) % maxSize;

当删除一个元素时,(queue.front + 1) % maxSize；

******************************************C++版本***********************************
#include <iostream>

using namespace std;

template <class T>
class cycleQueue
{
    private: 
        unsigned int m_size;
        int m_front;
        int m_rear;
        T*  m_data;
    public:
        cycleQueue(unsigned size)
            :m_size(size),
            m_front(0),
            m_rear(0)
        {   
            m_data = new T[size];
        }   

        ~cycleQueue()
        {   
            delete [] m_data;
        }   

        bool isEmpty()
        {   
            return m_front == m_rear;
        }   

        bool isFull() 
        {   
            return m_front == (m_rear + 1)%m_size;
        }   

        void push(T ele)throw(bad_exception)
        {
            if(isFull())
            {
                throw bad_exception();
            }
            m_data[m_rear] = ele;
            m_rear = (m_rear + 1)%m_size;
        }

        T pop() throw(bad_exception)
        {
            if(isEmpty())
            {
                throw bad_exception();
            }
            T tmp = m_data[m_front];
            m_front = (m_front + 1)%m_size;
            return tmp;
        }
};


int main()
{
    cycleQueue<int> q(5);
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    for (int i = 0; i < 4 ; i++)
        cout << q.pop() << endl;
    q.push(5);
    q.push(5);
    q.push(5);
    cout << q.pop() << endl;
    cout << q.pop() << endl;
    cout << q.pop() << endl;
    cout << q.pop() << endl;
    return 0;
}

链队：

//先定义结点
struct QNode{
    int data;
    QNode *next;
};
// 定义链队
struct LQueue
{
    QNode *front;
    QNode *rear;
};

void Init(LQueue *&lqu)
{
    lqu = new LQueue;
    lqu->front = lqu->rear = NULL;
}

int QueueEmpty(LQueue *lqu)
{
    if(lqu->front == NULL||lqu->rear == NULL)
        return 1;
    else 
        return 0;
}

void enQueue(LQueue *&lqu,int x)
{
    QNode *p = new QNode;
    p->data = x;
    p->next = NULL;
    if(lqu->rear == NULL)
        lqu->front = lqu->rear = p;
    else{
        lqu->rear->next = p;
        lqu->rear = p
    }
}

int deQueue(LQueue *&lqu,int &x)
{
    QNode *p;
    if(lqu->rear == NULL)
        return 0;
    else
        p=lqu->front;

    if(lqu->front == lqu->rear)      // 当链队中只有一个结点时，特殊处理
        lqu->front=lqu->rear=NULL;
    else
        lqu->front = lqu->front->next;
    x=p->data;
    free(p);
    return 1;
}