仅设尾指针的循环队列问题

仅设尾指针的循环队列 感觉思路没什么问题 但不知道哪里错了
输入一个整数序列：a 1 ,a 2​ ,a 3 ，…，a n ，进行入队或出队操作。用带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意：不设头指针），试编写相应的置空队、判队空、入队和出队等算法，并实现以下任务：对输入的a i，当a i>0时，将a i 入队；当a i=0时，队头元素出队，若出队时队空则发生下溢“UNDERFLOW”，一旦发生下溢，则停止处理。

输入格式:
测试数据有多组，处理到文件尾。每组测试数据首先输入正整数n（n≤30），再输入n个整数。

输出格式:
对于每组测试，若处理过程中未发生下溢，则依次输出队列中当前还存在的元素（每两个数据之间留一个空格），否则输出“UNDERFLOW”表示下溢（若最终队列为空，也输出“UNDERFLOW”）。引号不必输出。
输入样例:
11 1 2 3 4 5 6 0 0 7 8 0
7 1 2 3 0 0 0 0
输出样例:
4 5 6 7 8
UNDERFLOW

#include<iostream>
using namespace std;
typedef int elemtype;
struct QNode{
    elemtype data;
    QNode *next;
};
struct LinkQueue{
    QNode *rear;
    void init();
    void inqueue(elemtype e);
    void outqueue();
    bool empty();
    void getFront();
};
void LinkQueue::init(){
    rear=new QNode;
    rear->next=rear;
}
void LinkQueue::inqueue(elemtype e){
    QNode *p=new QNode;
    p->data=e;
    p->next=rear->next;
    rear->next=p;
    rear=p;
}
void LinkQueue::outqueue(){
    if(rear==rear->next) return;
    QNode *p=rear->next->next;
    rear->next->next=p->next;
    if(p==rear){
        rear=rear->next;
    }
    delete p;
}
bool LinkQueue::empty(){
    return rear=rear->next;
}
void solve(int n,int a[]){
    LinkQueue que;
    que.init();
    for(int i=0;i<n;i++){
        if(a[i]>0){
            que.inqueue(a[i]);
        }else if(que.empty()!=true&&a[i]==0){
            que.outqueue();
        }
    }
    if(que.empty()==true){
        cout<<"UNDERFLOW"<<endl;
    }else{
        int cnt=0;
        cout<<1111;
        for(int i=0;i<n;i++){
            cnt++;
            if(cnt!=1){
                cout<<" ";
            }
            cout<<a[i];
        }
    }
}
int main(){
    int n;
    while(cin>>n){
        int a[n];
        for(int i=0;i<n;i++){
            cin>>a[i];
        }
        solve(n,a);
    }
}

代码如下，希望采纳

#include <iostream>

using namespace std;

const int N = 35;

struct Queue
{
    int e[N];
    int tail; // 队尾指针
};

void InitQueue(Queue& q) // 初始化队列
{
    q.tail = 0;
}

bool IsEmpty(Queue q) // 判队空
{
    return q.tail == 0;
}

bool IsFull(Queue q) // 判队满
{
    return q.tail == N - 1;
}

bool EnQueue(Queue& q, int x) // 入队
{
    if (IsFull(q)) return false;

    q.e[q.tail] = x;
    q.tail = (q.tail + 1) % N;

    return true;
}

bool DeQueue(Queue& q, int& x) // 出队
{
    if (IsEmpty(q)) return false;

    x = q.e[0];
    for (int i = 1; i < q.tail; i++)
        q.e[i - 1] = q.e[i];
    q.tail--;

    return true;
}

int main()
{
    int n;
    while (cin >> n)
    {
        Queue q;
        InitQueue(q);

        for (int i = 0; i < n; i++)
        {
            int x;
            cin >> x;

            if (x > 0) EnQueue(q, x);
            else
            {
                int y;
                if (DeQueue(q, y)) cout << y << " ";
                else
                {
                    cout << "UNDERFLOW" << endl;
                    break;
                }
            }
        }

        if (IsEmpty(q)) cout << "UNDERFLOW" << endl;
        else
        {
            for (int i = 0; i < q.tail; i++)
                cout << q.e[i] << " ";
            cout << endl;
        }
    }

    return 0;
}