链式队列

Link Queue

//队列
//队列的链式存储（链式队列）：操作首先的单链表（尾部插入，头部删除）
//带头结点实现方式

#include<iostream>

using namespace std;

template<typename T>
struct QueueNode
{
    T   data;               //数据域
    QueueNode<T>* next;     //指针域
};

template<typename T>
class LinkQueue
{
public:
    LinkQueue();                             //构造函数
    ~LinkQueue();                            //析构函数

public:
    bool EnQueue(const T& e);                //入队列
    bool DeQueue(T& e);                      //出队列
    bool GetHead(T& e);                      //读取队头元素

    void DispList();                         //输出链式队列中所有元素
    int ListLength();                        //获取链式队列的 长度

    bool IsEmpty();                          //判断链式队列是否为空

private:
    QueueNode<T>* m_front;                   //头指针， 这一段允许出队
    QueueNode<T>* m_rear;                    //专门引入尾指针以方便入队
    int m_length;                            //记录长度
};

//构造函数
template<typename T>
LinkQueue<T>::LinkQueue()
{
    m_front = new QueueNode<T>;              //先创建一个头结点
    m_front->next = nullptr;
    m_rear = m_front;
    m_length = 0;
}

//析构函数进行资源释放
template<typename T>
LinkQueue<T>::~LinkQueue()
{
    QueueNode<T> *pNode = m_front->next;
    QueueNode<T> *ptmp;
    while (pNode != nullptr)
    {
        ptmp = pNode;
        pNode = pNode->next;
        delete ptmp;
    }
    delete m_front;         //释放头结点
    m_front = m_rear = nullptr;
    m_length = 0;
    
}

//入队列（增加数据），也就是从队列增加数据
template<typename T>
bool LinkQueue<T>::EnQueue(const T& e)
{
    QueueNode<T> *node = new QueueNode<T>;
    node->data = e;
    node->next = nullptr;
    // if(IsEmpty() == true)
    // {
    //     m_front->next = node;
    // }
    m_rear->next = node;            //新节点插入到 m_rear后面
    m_rear = node;                  //更新队尾指针

    m_length++;
    return true;
}

//出队列(删除数据)
template<typename T>
bool LinkQueue<T>::DeQueue(T& e)temp
{
    if(IsEmpty() == true)
    {
        cout << "当前链式队列为空，不能进行出队操作" << endl;
        return false;
    }

    QueueNode<T> *p_willdel = m_front->next;
    e = p_willdel->data;

    m_front->next = p_willdel->next;
    if(m_rear == p_willdel)         //队列中只有一个元素
    {
        m_rear = m_front;           //设置队列为空，尾指针，指向头指针
    }
    delete p_willdel;
    m_length--;
    return true;
}

//读取队头元素，但是该元素并没有出队列

template<typename T>
bool LinkQueue<T>::GetHead(T& e)
{
        if(IsEmpty() == true)
    {
        cout << "当前链式队列为空，不能取得队头元素" << endl;
        return false;
    }

    e = m_front->next->data;
    cout << "队头为 " << e << endl;
    return true;
}

//显示所有元素
template<typename T>
void LinkQueue<T>::DispList()
{
    QueueNode<T> *p = m_front->next;
    while(p != nullptr)
    {
        cout << p->data << " ";         //每个元素之间以空格分隔
        p = p->next;
    }
    cout << endl;
}


//获得队列长度
template<typename T>
int LinkQueue<T>::ListLength()
{
    return m_length;
}

//判断链式队列是否为空
template<typename T>
bool LinkQueue<T>::IsEmpty()
{
    if(m_front == m_rear)
    {
        return true;
    }
    return false;
}
int main()
{
    LinkQueue<int> queue;
    queue.EnQueue(1);
    queue.EnQueue(2);
    queue.EnQueue(3);
    queue.EnQueue(4);
    queue.EnQueue(5);
    queue.EnQueue(6);
    queue.DispList();

    int temp;
    queue.DeQueue(temp);
    queue.DispList();

    queue.EnQueue(7);
    queue.DispList();

    queue.GetHead(temp);
    return 0;
}