数据结构学习记录之队列篇（单链表实现队列的基本操作）

Queue.hpp

/***
 * 使用链表实现队列
 * */

#include <iostream>

template<class T>
class NodeQueue
{
public:
    T data;
    NodeQueue<T>* next;
    explicit NodeQueue(T value, NodeQueue<T>* link = nullptr);
};

template<class T>
NodeQueue<T>::NodeQueue(T value, NodeQueue<T> *link): data(value), next(link)
{

}


template<class T>
class Queue
{
private:
    NodeQueue<T>* myFront;
    NodeQueue<T>* myBack;

public:
    Queue();
    Queue(const Queue<T>& original);
    ~Queue();

    const Queue<T>& operator=(const Queue<T>& rightHandSide);
    bool empty() const;
    void enqueue(const T& value);
    void display() const;
    NodeQueue<T>* front() const;
    void dequeue();
};

template<class T>
void Queue<T>::dequeue()
{
    if (!empty())
    {
        auto ptr = myFront;
        myFront = myFront->next;
        delete ptr;
        if (myFront == nullptr)
        {
            myBack = nullptr;
        }
    }
}

template<class T>
NodeQueue<T>* Queue<T>::front() const
{
    if (!empty())
    {
        return myFront;
    }
    return nullptr;
}

template<class T>
void Queue<T>::display() const
{
    NodeQueue<T>* ptr = nullptr;
    for (ptr = myFront; ptr != nullptr; ptr = ptr->next)
    {
        std::cout << ptr->data << " ";
    }
    std::cout << std::endl;
}

template<class T>
void Queue<T>::enqueue(const T &value)
{
    auto newPtr = new NodeQueue<T>(value);
    if (empty())
    {
        myFront = myBack = newPtr;
    }
    else
    {
        myBack->next = newPtr;
        myBack = newPtr;
    }
}

template<class T>
bool Queue<T>::empty() const
{
    return myFront == nullptr;
}

template<class T>
const Queue<T> &Queue<T>::operator=(const Queue<T> &rightHandSide)
{
    if (this != &rightHandSide)
    {
        this->~Queue();
        if (rightHandSide.empty())
        {
            myFront = myBack = nullptr;
        }
        else
        {
            myFront = myBack = new NodeQueue<T>(rightHandSide.front()->data);
            auto rhsPtr = rightHandSide.myFront->next;
            while (rhsPtr != nullptr)
            {
                myBack->next = new NodeQueue<T>(rhsPtr->data);
                myBack = myBack->next;
                rhsPtr = rhsPtr->next;
            }
        }
    }
    return *this;
}

template<class T>
Queue<T>::~Queue()
{
    NodeQueue<T>* prev = myFront;
    NodeQueue<T>* ptr = nullptr;
    while (prev != nullptr)
    {
        ptr = prev->next;
        delete prev;
        prev = ptr;
    }
}

template<class T>
Queue<T>::Queue(const Queue<T> &original)
{
    myFront = myBack = nullptr;
    if (!original.empty())
    {
        myFront = myBack = new NodeQueue<T>(original.front());

        auto origPtr = original.myFront->next;
        while (origPtr != nullptr)
        {
            myBack->next = new NodeQueue<T>(origPtr->data);
            myBack = myBack->next;
            origPtr = origPtr->next;
        }
    }
}

template<class T>
Queue<T>::Queue(): myFront(nullptr), myBack(nullptr)
{

}