C++——手动封装一个循环顺序队列类

手动封装一个循环顺序队列类(Queue)
私有成员属性：存放队列的数组、两个变量分别记录队头和队尾下标
公有成员函数：入队(push( type value ))
出队(pop())
展示(show)
求队列长度(size())：要求时间复杂度在常量级别
判满(bool full())
判空(bool empty())

 代码如下：

/**
  ******************************************************************************
  * @file              : StackList.cpp
  * @author            : XHJ
  * @date              : 2023/5/9
  * @description       : 手动封装一个循环顺序队列类(Queue)
                            私有成员属性：存放队列的数组、两个变量分别记录队头和队尾下标
                            公有成员函数：入队(push( type value ))
                            出队(pop())
                            展示(show)
                            求队列长度(size())：要求时间复杂度在常量级别
                            判满(bool full())
                            判空(bool empty())
  ******************************************************************************
  */

#include <iostream>

using namespace std;

#define MAXSIZE 100

typedef int datatype;

class Queuelist {
private:
    //数据元素
    datatype data[MAXSIZE];
    //队头：出队在队头
    int front;
    //队尾：入队在队尾
    int rear;
public:
    //构造函数
    Queuelist(int front, int rear) {
        this->front = front;
        this->rear = rear;
    }

    //循环队列入队
    int push(datatype e);

    //循环队列出队
    int pop();

    //循环队列遍历
    void show();

    //求循环队列个数
    int size();

    //循环队列判空
    bool empty();

    //循环队列判满
    bool full();
};

int main() {
    int n;  //插入循环队列的元素个数
    Queuelist queue(0, 0);  //实例化循环队列对象
    cout << "请输入插入循环队列的元素个数：";
    cin >> n;
    datatype e;
    //循环入队
    for (int i = 1; i <= n; ++i) {
        cout << "请输入第" << i << "个元素：";
        cin >> e;
        queue.push(e);
    }
    cout << "循环队列中元素个数：" << queue.size() << endl;
    //循环队列遍历
    queue.show();

    //循环队列出队
    cout << endl << "<-------循环队列出队------->" << endl;
    queue.pop();
    cout << "循环队列中元素个数：" << queue.size() << endl;
    cout << endl << "<-------循环队列出队------->" << endl;
    queue.pop();
    cout << "循环队列中元素个数：" << queue.size() << endl;
}

/**
 * @brief 循环队列入队
 * @param e 入队元素
 * @return 成功返回0，失败返回-1
 */
int Queuelist::push(datatype e) {
    //判断循环队列是否已满
    if (full()) {
        cout << "循环队列已满，入队失败！" << endl;
        return -1;
    }
    //入队
    data[rear] = e;
    rear = (rear + 1) % MAXSIZE;
    return 0;
}

/**
 * @brief 循环队列出队
 * @return 成功返回0，失败返回-1
 */
int Queuelist::pop() {
    //判断循环队列是否为空
    if (empty()) {
        cout << "循环队列已空，出队失败！" << endl;
        return -1;
    }
    //出队
    cout << "出队元素是：" << data[front] << endl;
    front = (front + 1) % MAXSIZE;
    return 0;
}

/**
 * @brief 循环队列遍历
 * @return 成功返回0，失败返回-1
 */
void Queuelist::show() {
    //判断链表是否为空
    if (empty()) {
        cout << "循环队列已空，遍历失败！" << endl;
        return;
    }
    //循环遍历
    cout << endl << "循环队列元素是：" << endl;
    for (int i = front; i != rear; i = (i + 1) % MAXSIZE) {
        cout << data[i] << "  ";
    }
}

/**
 * @brief 求循环队列元素个数
 * @return 返回元素个数
 */
int Queuelist::size() {
    return (rear - front + MAXSIZE) % MAXSIZE;
}

/**
 * @brief 判空
 * @return 空返回true,不空返回false
 */
bool Queuelist::empty() {
    if (front == rear)
        return true;
    else
        return false;
}

/**
 * @brief 判满
 * @return 满返回true,不满返回false
 */
bool Queuelist::full() {
    if (front == (rear + 1) % MAXSIZE)
        return true;
    else
        return false;
}

运行结果如下：