迴圈佇列的順序儲存實現，包括入隊，出隊，清隊，銷燬隊，遍歷佇列等

佇列（queue）是一種先進先出（first in fist out，縮寫為FIFO）的線性表，它只允許在表的一端進行插入，而在另一端進行刪除元素。允許插入的一端稱為隊尾（rear），允許刪除的一端稱為隊頭（front）。

具體的程式碼實現如下

#include <iostream>
#include <cstdlib>
#include <cstdio>

using namespace std;

#define MAXSIZE     100
#define OVERFLOW    -2
#define OK
 
          1
#define TRUE        1
#define FALSE       0
#define ERROR       1

typedef int QElemType;
typedef int Status;
///迴圈佇列的順序儲存方式
struct SqQueue
{
    QElemType *base;
    int front;
    int rear;
};

Status InitQueue(SqQueue &Q);///構造一個空佇列
Status DestroyQueue(SqQueue &Q);///銷燬佇列Q，Q不再存在
Status ClearQueue
 
(SqQueue &Q);///將Q清為空佇列
Status QueueEmpty(SqQueue Q);///若佇列Q為空，則返回TRUE，否則返回FALSE
int QueueLength(SqQueue Q);///返回Q的元素個數，即為佇列的長度
Status GetHead(SqQueue Q, QElemType &e);///若佇列不為空，則用e返回Q的隊頭元素，並返回OK；否則返回ERROR
Status EnQueue(SqQueue &Q, QElemType e);///插入元素e為Q的新的隊尾元素
Status DeQueue(SqQueue &Q, QElemType &
 
e);///若佇列不空，則刪除Q的隊頭元素，用e返回其值，並返回OK；否則返回ERROR
void visit(QElemType e);///輸出元素e
Status QueueTraverse(SqQueue Q, void(*visit)(QElemType));///遍歷佇列Q


Status InitQueue(SqQueue &Q)
{
    ///構造一個空佇列Q
    Q.base = (QElemType *)malloc(MAXSIZE * sizeof(QElemType));
    if(!Q.base)
        exit(OVERFLOW);
    Q.front = Q.rear = 0;
    return OK;
}

Status DestroyQueue(SqQueue &Q){
    ///銷燬佇列Q，Q不再存在
    if(Q.base)
        free(Q.base);
    Q.base = NULL;
    Q.front = Q.rear = 0;
    return OK;
}

Status ClearQueue(SqQueue &Q){
    ///將Q清為空佇列
    Q.front = Q.rear = 0;
    return OK;
}

Status QueueEmpty(SqQueue Q){
    ///判斷佇列是否為空
    if(Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

int QueueLength(SqQueue Q)
{
    ///返回Q的元素個數，即佇列的長度
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

Status GetHead(SqQueue Q, QElemType &e){
    ///若佇列不為空，則用e返回Q的隊頭元素，並返回OK；否則返回ERROR
    if(Q.front == Q.rear)
        return ERROR;
    e = Q.base[Q.front];
    return OK;
}

Status EnQueue(SqQueue &Q, QElemType e)
{
    ///插入元素e，為Q的新的隊尾元素
    if((Q.rear + 1) % MAXSIZE == Q.front) ///佇列滿
        return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXSIZE;
    return OK;
}

Status DeQueue(SqQueue &Q, QElemType &e)
{
    ///若佇列不空，則刪除Q的隊頭元素，用e返回其值，並返回OK;否則返回ERROR
    if(Q.front == Q.rear)
        return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXSIZE;
    return OK;
}

void visit(QElemType e){
    ///輸出元素e
    cout << e << " ";
}
Status QueueTraverse(SqQueue Q, void(*visit)(QElemType)){
    ///利用指標函式，遍歷佇列Q
    int i;
    i = Q.front;
    while(i != Q.rear){
        visit(Q.base[i]);
        i = (i + 1) % MAXSIZE;
    }
    cout << endl;
    return OK;
}

int main()
{
    int i = 0,l;
    Status j;
    QElemType e;
    SqQueue Q;
    InitQueue(Q);
    if(!QueueEmpty(Q))
        cout << "佇列為空。" << endl;
    cout << "請輸入值到佇列中，長度應小於" << MAXSIZE -1 << endl;
    do{
        cin >> e;
        ++i;
        if(e == -1){
            break;
        }
        EnQueue(Q,e);
    }while(i < MAXSIZE -1);

    cout << "佇列的長度為：" << QueueLength(Q) << endl;
    cout << "開始從隊頭刪除元素，從隊尾插入元素:" << endl;
    for(i = 0; i < QueueLength(Q); ++i){
        DeQueue(Q,e);
        cout << "刪除的元素為：" << e << ".請輸入新的值進行插入：";
        cin >> e;
        EnQueue(Q,e);
    }
    l = QueueLength(Q);
    cout << "佇列的元素為：" << endl;
    QueueTraverse(Q,visit);
    j = GetHead(Q,e);
    cout << "佇列的首元素為：" << e << endl;
    ClearQueue(Q);
    if(!QueueEmpty(Q))
        cout << "佇列不為空！" << endl;
    else
        cout << "佇列為空！" << endl;
    DestroyQueue(Q);
    return 0;
}

執行結果如下：

佇列不宜像棧那樣，進行儲存在分配陣列空間，因為佇列的實際可用空間並未沾滿。