数据结构——链式队列模板类实现

原創

2020-02-21 17:32

数据结构笔记3.3.3 Queue
与栈类似，队列也分成顺序队列和链式队列。用单链表表示的链式队列特别适合于元素变动比较大的情形，而且不存在队列FULL而溢出的情况。另外，假若程序中需要多个队列，与多个栈的情形一样，最好使用链式队列。这样不会出现存储分配不合理的问题，也不需要考虑存储的移动。下面就给出相应的代码。
链式队列模板类代码：

//数据结构——链式队列模板类
#include <iostream>
using namespace std;
template<class T>
struct LinkNode {
    T data;                 //队列每个节点的数据域
    LinkNode<T> *next;      //队列每个节点的指针域
    //构造函数
    LinkNode(T x, LinkNode<T> *p = NULL) {
        data = x;
        next = p;
    }
};
template<class T>
class LinkedQueue {
public:
    LinkedQueue();                          //构造函数
    ~LinkedQueue();                            //析构函数
    bool enQueue(const T & x);              //将x加入队列当中
    bool delQueue(T & x);                   //删除队头元素，x返回其值
    bool getFront(T & x) const;             //查看队头元素的值
    void makeEmpty();                       //将队列清空
    bool isEmpty() const;                   //判断队列是否为NULL
    int getSize() const;                    //返回队列元素的个数
    void output(ostream & out);             //输出队列元素，由重载运算符函数调用
private:
    LinkNode<T> *front, *rear;              //队头、队尾指针
};

//函数定义
template<class T>
LinkedQueue<T>::LinkedQueue() {
    //构造函数,初始化队头和队尾指针
    front = rear = NULL;
}

template<class T>
void LinkedQueue<T>::makeEmpty() {
    //置空队列，释放链表中的所有节点
    LinkNode<T> *current;   
    while (front != NULL) {
        current = front;
        front = front->next;
        delete current;
    }
}

template<class T>
bool LinkedQueue<T>::enQueue(const T & x) {
    //元素x进入队尾
    if (NULL == front) {
        //如果是空队列，直接用指针开辟节点
        front = rear = new LinkNode<T>(x);
        if (NULL == front) {
            //分配内存失败返回false
            return false;
        }
    }
    else {
        rear->next = new LinkNode<T>(x);
        if (NULL == rear->next) {       //直接用rear的next开辟新节点
            return false;
        }
        rear = rear->next;              //更新尾指针
    }
    return true;
}

template<class T>
bool LinkedQueue<T>::delQueue(T & x) {
    //如果队列不是NULL，删除队头节点，函数返回true，否则返回false
    if (isEmpty()) {                    //队列为空，出队失败
        return false;
    }
    LinkNode<T> *Del = front;
    x = front->data;
    front = front->next;
    delete Del;
    return true;
}

template<class T>
bool LinkedQueue<T>::getFront(T & x)const {
    //若队列不为NULL，函数返回队头元素的值和true，否则返回false
    if (isEmpty()) {
        return false;
    }
    x = front->data;
    return true;
}

template<class T>
int LinkedQueue<T>::getSize()const {
    //函数返回队列元素的个数
    LinkNode<T> *p = front;
    int queueEleAmount = 0;
    while (p != NULL) {
        queueEleAmount++;
        p = p->next;
    }
    return queueEleAmount;
}

template<class T>
bool LinkedQueue<T>::isEmpty() const {
    //判断队列是否为NULL并返回true，否则返回false
    if (front == NULL) {
        return true;
    }
    else {
        return false;
    }
}

template<class T>
LinkedQueue<T>::~LinkedQueue() {
    //析构函数，释放程序中的资源
    makeEmpty();
}

template<class T>
void LinkedQueue<T>::output(ostream & out) {
    //输出队列中的元素，被重载<<函数调用
    LinkNode<T> *current = front;
    while (current != NULL) {
        out << current->data << " ";
        current = current->next;
    }
    cout << endl;
}

template<class T>
ostream & operator << (ostream & out, LinkedQueue<T> &LQ) {
    //重载<<运算符函数，调用output实现队列的输出
    LQ.output(out);
    return out;
}

Main函数测试代码：

int main()
{
    LinkedQueue<int> link_queue;
    link_queue.enQueue(1);              //入队测试
    link_queue.enQueue(2);
    link_queue.enQueue(3);
    link_queue.enQueue(4);
    link_queue.enQueue(5);
    cout << link_queue;
    int del_value1, del_value2;
    link_queue.delQueue(del_value1);    //出队测试
    link_queue.delQueue(del_value2);
    cout << link_queue;
    int queue_head = 0;
    link_queue.getFront(queue_head);    //读取队头测试
    cout << queue_head << endl;
    link_queue.makeEmpty();             //set NULL test
    if (link_queue.isEmpty()) {
        cout << "Queue is null" << endl;
    }
    cout << link_queue.getSize() << endl;//返回队列元素个数测试

    system("pause");
    return 0;
}