Queue principle

First in first out FIFO:first in first out

Normal queue:

1. There is a limit on the number
2. If the subsequent members don't move forward, the memory will be wasted. If the moving efficiency is low, the speed will be slow.
   

Circular queue:

Object oriented design of queue structure

class MyQueue{
    public:
        MyQueue(int queueCapacity); //Create & queue initqueue
        virtual ~MyQueue();  //Destroyqueue
        void ClearQueue(); //Clearqueue & clear queue
        bool QueueEmpty() const; //Queue empty (q)
        bool QueueFull() const; //Full queue 
        int QueueLength() const; //QueueLength(Q) queue length
        bool EnQueue(int element); //Enqueue & new element
        bool DeQueue(int &element); // Dequeue & first element
        void QueueTraverse(); //QueueTraverse(Q, visit()) traverses the queue
    private:
        int *m_pQueue;  // Queue array pointer 
        int m_iQueueLen;  //Number of queue elements 
        int m_iQueueCapacity;  //Queue array capacity 
}; 

Implementation of circular queue code

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

MyQueue::MyQueue(int queueCapacity) {
    m_iQueueCapacity = queueCapacity;
    m_pQueue = new int[m_iQueueCapacity];
    ClearQueue();
}
MyQueue::~MyQueue() {
    delete []m_pQueue;
    m_pQueue = NULL;
}

void MyQueue::ClearQueue() {
    m_iHead = 0;
    m_iTail = 0;
    m_iQueueLen = 0;
}
bool MyQueue::QueueEmpty() const {
    if(m_iQueueLen == 0) {
        return true;
    }else {
        return false;
    }
}
bool MyQueue::QueueFull() const {
    if(m_iQueueLen == m_iQueueCapacity) {
        return true;
    } else {
        return false;
    }
} 
int MyQueue::QueueLength() const {
    return m_iQueueLen;
}
bool MyQueue::EnQueue(int element) {
    if(QueueFull()){
        return false;
    } else {
       m_pQueue[m_iTail] = element;
       m_iTail += 1;
       m_iTail = m_iTail % m_iQueueCapacity;
       m_iQueueLen++;
       return true;
    }
}
bool MyQueue::DeQueue(int &element) {
    if(QueueEmpty()){
        return false;
    } else {
       element = m_pQueue[m_iHead];
       m_iHead += 1; 
       m_iHead = m_iHead % m_iQueueCapacity;
       m_iQueueLen--;
       return true;
    }
}
void MyQueue::QueueTraverse() {
    for(int i = m_iHead; i < m_iQueueLen; i++) {
        cout << m_pQueue[i % m_iQueueLen] << endl;
    }
}

Ring queue implementation detection

#include<iostream>
#include<stdlib.h>
#include"MyQueue.h"
int main(){
    MyQueue *p = new MyQueue(4);//The current queue can hold up to 4 elements
    p->EnQueue(10);
    p->EnQueue(12);
    p->EnQueue(19);
    p->EnQueue(90);
    p->QueueTraverse();
    int e = 0;
    p->DeQueue(e);
    cout << endl;
    cout << e << endl;
    
    p->DeQueue(e);
    cout << endl;
    cout << e << endl;
    
    cout << endl;
    p->QueueTraverse();
    
    p->ClearQueue();
    p->QueueTraverse();
    delete p;
    p = NULL;
  
    return 0;
}

Operation result: