佇列的實現可以基於陣列實現，也可以基於單鏈表實現。
下面給出陣列實現，為防止佇列多次進行插入和刪除操作導致的前面的陣列空間被浪費，採用迴圈佇列的方式。

宣告一個佇列類，這裡要注意maxn的大小，因為是迴圈佇列，所以不用太大。如果太大，類又是在main函式中定義的，就有可能導致棧溢位。

class Queue
{
public:
        Queue();
        int  PUSH(int x);
        int POP();
        int MINUS();
        int MAX();
private:
       int font;
       int
 
 rear;
       int data[maxn]; // 這是基於陣列的線形佇列
       int maxnum;
};

解構函式：

Queue::Queue()
{
        rear = 0;
        font = 0;
        maxnum = INT_MIN;
        memset(data,0,sizeof(data));
}

插入操作：

int  Queue::PUSH(int x)
{
       if((rear + 1)% maxn == font)
              return 0;
        else
        {
                data[rear] = x;
                rear = (rear + 1
 
) % maxn;
                return 1;
        }
}

取隊頭元素：

int Queue::POP()
{
       if(rear == font)
            return 0;
        else
        {
               font = (font + 1) % maxn;
               return 1;
        }
}

相反數逆轉：

int Queue::MINUS()
{
          if(rear == font )
                return
 
 0;
          else
          {
            for(int i = font;i < rear ;i = (i+1) %maxn)
                    data[i] = -data[i];
            return 1;
           }
}

注意：因為相反數操作是對於每一個元素的改變，因此時間複雜度為線性級O(n)

找最大元素：

int Queue::MAX()
{
     if(rear == font)
         return INT_MIN;
    else
    {
          maxnum = INT_MIN;
          for(int i = font;i <rear ;i = (i+1) %maxn)
          {
              if(data[i] > maxnum)
                   maxnum = data[i];
          }
          return maxnum;
    }
}

很顯然，這種找最大數的方案非常慢。快速差找最大數，可以有以下兩種方案：
1.採用一個輔助棧記錄資訊。
2.用雙棧實現佇列。