队列

特点：

与栈相反，队列是一种先入先出(FIFO)的线性表
它允许在表的一端插入元素，在另一端删除元素
允许插入的一端是队尾(rear)，允许删除的一端是队头(front)

用于测试的文件，以及测试结果以及其他简单数据结构的实现可以去作者GitHub上查看

 （下面代码只是最初实现，后续如果有修改，由于太麻烦，不会再更改下文，仅仅更新Github上的代码文件）

实现代码：

#define QueueDataType int
#define InitQueueData 12345

class QueueNode {
public:
    QueueNode() {
        data = InitQueueData;
        next = nullptr;
    }

    QueueNode(QueueDataType ele) : data(ele), next(nullptr) {

    }

    QueueDataType data;
    QueueNode *next;
};

class Queue {
public:
    Queue();
    Queue(int len);    // 创建一个有len个结点的队列
    ~Queue();

    // 队列的初始化
    void QueueInit();

    // 销毁队列
    void QueueDestroy();

    // 将队列清空
    void QueueClear();

    // 判断是否为空队列
    bool QueueEmpty();

    // 获取队列长度，即队列中元素个数
    int QueueLength();

    // 获取队列头结点保存的数据值
    bool QueueGetHead(QueueDataType &value);

    // 入队，插入新的队列结点
    bool QueueEn(QueueDataType value);

    // 出队，删除队尾结点
    bool QueueDe();
    bool QueueDe(QueueDataType &value);    // 出队并返回其值

    // 遍历队列，从队头到队尾
    void QueueTraverse();

private:
    QueueNode *front;    // 队头
    QueueNode *rear;     // 队尾
};

Queue::Queue()
{
    QueueInit();
}

Queue::Queue(int len)
{
    QueueInit();

    for (int i = 0; i < len; i++) {
        QueueDataType temp;
        std::cin >> temp;
        QueueEn(temp);
    }
}

Queue::~Queue()
{
    QueueClear();
    QueueDestroy();
}

void Queue::QueueInit()
{
    QueueNode *node = new(std::nothrow) QueueNode;

    if (!node)
        std::exit(1);

    front = node;
    rear = node;
}

void Queue::QueueDestroy()
{
    delete(front);
}

void Queue::QueueClear()
{
    if (QueueEmpty())    // 已经是空队列
        return;

    QueueNode *cur = front->next;
    QueueNode *next = cur->next;

    while (cur != rear) {    // 依次释放每一个队列元素
        delete(cur);
        cur = next;
        next = next->next;
    }

    delete(rear);
    rear = front;
}

bool Queue::QueueEmpty()
{
    return (front == rear) ? true : false;
}

int Queue::QueueLength()
{
    int cnt = 0;

    QueueNode *cur = front;

    while (cur != rear) {
        cnt++;
        cur = cur->next;
    }

    return cnt;
}

bool Queue::QueueGetHead(QueueDataType &value)
{
    if (QueueEmpty())    // 空队列
        return false;

    value = front->next->data;
}

bool Queue::QueueEn(QueueDataType value)
{
    QueueNode* node = new(std::nothrow) QueueNode(value);

    if (!node)
        std::exit(1);

    rear->next = node;
    rear = node;

    return true;
}

bool Queue::QueueDe()
{
    if (QueueEmpty())
        return false;

    if (QueueLength() == 1) {
        delete(front->next);
        front->next = nullptr;
        rear = front;
    }
    else {
        QueueNode* node = front->next;
        front->next = node->next;
        delete(node);
    }

    return true;
}

bool Queue::QueueDe(QueueDataType &value)
{
    if (QueueEmpty())
        return false;

    if (QueueLength() == 1) {
        value = front->next->data;
        delete(front->next);
        front->next = nullptr;
        rear = front;
    }
    else {
        value = front->next->data;
        QueueNode* node = front->next;
        front->next = node->next;
        delete(node);
    }

    return true;
}

void Queue::QueueTraverse()
{
    QueueNode* cur = front->next;

    while (cur != nullptr) {
        std::cout << cur->data << std::endl;
        cur = cur->next;
    }
}