最小和最大优先循环队列（C++）

#include <iostream>

#define MAXSIZE 6

/**
 * 循环队列思路:
 * front 指向队列第一个元素  rear 指向队列最后一个元素的后一个位置，当数组满时，rear最后一个位置，该位置不存储元素
 *
 * 队列为空的条件  rear == front
 * 队列满的条件   Length（） = maxSize - 1
 * 队列长度     (rear - front + maxSize) % maxSize
 * 对头插入元素     front = (front + 1) % maxSize
 * 对尾插入元素     rear = (rear + 1) % maxSize
 */

using namespace std;
enum StatusCode {
    UNDER_FLOW, OVER_FLOW, SUCCESS
};

template<typename T>
class CircleQueue {
protected:
    //头尾指针
    int front{}, rear{};

    int maxSize{};
    //指向循环队列
    T *elem;

    void init();

    bool Full() const;

public:
    explicit CircleQueue(int size = MAXSIZE);

    virtual ~CircleQueue();

    int Length() const;

    bool Empty();

    void Traverse(void (*Visit)(T &));

    StatusCode inQueue(T &e);

    StatusCode outQueue(T &e);

    StatusCode getHead(T &e);

    CircleQueue(const CircleQueue<T> &copy);

    CircleQueue<T> &operator=(const CircleQueue<T> &copy);

};

template<typename T>
void CircleQueue<T>::init() {
    rear = front = 0;
}

template<typename T>
bool CircleQueue<T>::Full() const {
    return Length() == maxSize - 1;
}

template<typename T>
CircleQueue<T>::CircleQueue(int size) {
    maxSize = size;
    elem = new T[maxSize];
    init();
}

template<typename T>
CircleQueue<T>::~CircleQueue() {
    delete[]elem;
}

template<typename T>
int CircleQueue<T>::Length() const {
    return (rear - front + maxSize) % maxSize;
}

template<typename T>
void CircleQueue<T>::Traverse(void (*Visit)(T &)) {
    for (int temp = front; temp != rear; ++temp) {
        (*Visit)(elem[temp]);
    }
}

template<typename T>
void PrintQueue(T val) {
    cout << val << " ";
}

template<typename T>
bool CircleQueue<T>::Empty() {
    return front == rear;
}

template<typename T>
StatusCode CircleQueue<T>::inQueue(T &e) {
    if (Full()) {
        return OVER_FLOW;
    } else {
        elem[rear] = e;
        rear = (rear + 1) % maxSize;
        return SUCCESS;
    }
}

template<typename T>
StatusCode CircleQueue<T>::getHead(T &e) {
    if (Empty()) {
        return UNDER_FLOW;
    } else {
        e = elem[front];
        return SUCCESS;
    }
}

template<typename T>
StatusCode CircleQueue<T>::outQueue(T &e) {
    if (!Empty()) {
        e = elem[front];
        front = (front + 1) % maxSize;

        return SUCCESS;
    } else {
        return UNDER_FLOW;
    }
}

template<typename T>
CircleQueue<T>::CircleQueue(const CircleQueue<T> &copy) {
    this->elem = new T[copy.maxSize];
    this->maxSize = copy.maxSize;
    front = copy.front;
    rear = copy.rear;

    for (int curPosition = front; curPosition != rear; curPosition = (curPosition + 1) % maxSize) {
        elem[curPosition] = copy.elem[curPosition];
    }
}

template<typename T>
CircleQueue<T> &CircleQueue<T>::operator=(const CircleQueue<T> &copy) {
    if (&copy != this) {
        delete[] elem;
        elem = new T[copy.maxSize];
        maxSize = copy.maxSize;

        front = copy.front;
        rear = copy.rear;
        for (int curPosition = front; curPosition != rear; curPosition = curPosition + 1) {
            elem[curPosition] = copy.elem[curPosition];
        }
    }
    return *this;
}

//最小优先循环队列
template<typename T>
class MinPriorityQueue : public CircleQueue<T> {
public:
    StatusCode inQueue(const T &e);
};

template<typename T>
StatusCode MinPriorityQueue<T>::inQueue(const T &e) {
    if (CircleQueue<T>::Full()) {
        return OVER_FLOW;
    } else {
        //获取最后一个元素位置
        int position = (CircleQueue<T>::rear - 1) % CircleQueue<T>::maxSize;
        //队列不为空，插入元素e大于当前位置元素，将当前位置元素向后移动，依次向前遍历
        while (!CircleQueue<T>::Empty() && CircleQueue<T>::elem[position] >= e && position >= 0){

            CircleQueue<T>::elem[position + 1] = CircleQueue<T>::elem[position];
            //先前移动
            position = position - 1;
        }
        //如果e刚好在队列中最小，那么直接插入到尾部，否则找到插入满足插入e时为降序的位置，此时该位置为空，插入e
        CircleQueue<T>::elem[position + 1] = e;
        //尾部指针向后移动
        CircleQueue<T>::rear = (CircleQueue<T>::rear + 1) % CircleQueue<T>::maxSize;

        return SUCCESS;
    }
}

//最大优先队列
template<typename T>
class MaxPriorityQueue : public CircleQueue<T> {
public:
    StatusCode inQueue(const T &e);
};

template<typename T>
StatusCode MaxPriorityQueue<T>::inQueue(const T &e) {
    if (CircleQueue<T>::Full()) {
        return OVER_FLOW;
    } else {
        //获取最后一个元素位置
        int position = (CircleQueue<T>::rear - 1) % CircleQueue<T>::maxSize;
        //队列不为空，插入元素e大于当前位置元素，将当前位置元素向后移动，依次向前遍历
        while (!CircleQueue<T>::Empty() && CircleQueue<T>::elem[position] <= e && position >= 0){

            CircleQueue<T>::elem[position + 1] = CircleQueue<T>::elem[position];
            //先前移动
            position = position - 1;
        }
        //如果e刚好在队列中最小，那么直接插入到尾部，否则找到插入满足插入e时为降序的位置，此时该位置为空，插入e
        CircleQueue<T>::elem[position + 1] = e;
        //尾部指针向后移动
        CircleQueue<T>::rear = (CircleQueue<T>::rear + 1) % CircleQueue<T>::maxSize;

        return SUCCESS;
    }
}

int main() {
    MinPriorityQueue<int> lq;
    lq.inQueue(19);
    lq.inQueue(9);
    lq.inQueue(1);
    lq.inQueue(20);
    lq.inQueue(2);

    lq.Traverse(PrintQueue);

    /*CircleQueue<int> copyQueue = CircleQueue<int> (lq);
    copyQueue.Traverse(PrintQueue);*/

    /*CircleQueue<int> cs;
    cs = lq;
    cs.Traverse(PrintQueue);*/
    //lq.outQueue(e);
    /*StatusCode statusCode = lq.getHead(e);
    cout << statusCode << endl;
    cout << e << endl;*/

    //lq.Traverse(PrintQueue);
    cout << endl;

    return 0;
}

 

       其他代码来自书上，在学优先循环队列时，书上的代码很麻烦而且不能和之前的代码兼容，所以我自己用比较笨的方法写了最大和最小优先循环队列，若题主有更好的解法欢迎在评论区给我留言。