队列的链表方式实现

1、像堆栈一样，也可以使用链表来实现一个队列。此时需要两个变量 f r o n t和r e a r来分别跟踪队列的两端，这时有两种可能的情形：从 f r o n t开始链接到 r e a r（如a所示）或从 r e a r开始链接到f r o n t（如图 b所示） 。不同的链接方向将使添加和删除操作的难易程度有所不同。图 6 - 8和6 - 9分别演示了添加元素和删除元素的过程。可以看到，两种链接方向都很适合于添加操作，而从f r o n t到r e a r的链接更便于删除操作的执行。因此，我们将采用从 f r o n t到r e a r的链接模式。可以取初值 f r o n t = r e a r = 0，并且认定当且仅当队列为空时 f r o n t = 0。

2、链表队列的实现

节点定义：Node.h

#ifndef NODE_H
#define NODE_H
template<class T>
class LinkedQueue;//声明模板类

template<class T>
class Node
{
    friend class LinkedQueue<T>;//声明为友元，因为需要访问Node的私有成员
    friend std::ostream& operator<<(std::ostream& output, const LinkedQueue<T>& q);
private:
    Node<T> *next;
    T data;
};
#endif

链表队列：

#ifndef LINKEDQUEUE_H
#define LINKEDQUEUE_H
#include <iostream>
#include <new>
#include "Node.h"
#include "exceptionerror.h"

template<class T>
class LinkedQueue
{
public:
    LinkedQueue():front(0),rear(0){}
    ~LinkedQueue();
    friend std::ostream& operator<<(std::ostream& output,const LinkedQueue<T>& q)
    {
        if (q.IsEmpty())
        {
            output << "empty queue" << std::endl;
        }
        else
        {
            Node<T>* p = q.front;
            while (p)
            {
                output << p->data << " ";
                p = p->next;
            }            
        }

        return output;
    }
    bool IsEmpty()const{ return front == 0; }
    bool IsFull()const;
    T First()const;//返回第一个元素
    T Last()const;//返回最后一个元素
    LinkedQueue<T>& Add(const T& x);//添加元素
    LinkedQueue<T>& Delete(T& x);//删除元素
    int Quantity()const;//返回元素个数
private:
    Node<T> *front;
    Node<T> *rear;
};

template<class T>
LinkedQueue<T>::~LinkedQueue()
{
    Node<T>* next;
    while (front)
    {
        next = front->next;
        delete front;
        front = next;
    }
}

template<class T>
bool LinkedQueue<T>::IsFull()const
{
    Node<T>* p;
    try
    {
        p = new Node<T>;
        delete p;
        return false;
    }
    catch (CMemoryException* e)
    {
        return true;
    }
}

template<class T>
T LinkedQueue<T>::First()const
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }

    return front->data;
}

template<class T>
T LinkedQueue<T>::Last()const
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }

    return rear->data;
}

template<class T>
LinkedQueue<T>& LinkedQueue<T>::Add(const T& x)
{
    Node<T> *p = new Node<T>;
    p->data = x;
    p->next = 0;
    if (front)
    {
        rear->next = p;
    }
    else front = p;

    rear = p;
    return *this;
}

template<class T>
LinkedQueue<T>& LinkedQueue<T>::Delete(T& x)
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }
    x = front->data;
    Node<T>* p = front;//为了释放front空间
    front = front->next;
    delete p;

    return *this;
}

template<class T>
int LinkedQueue<T>::Quantity()const
{
    if (IsEmpty())
    {
        return 0;
    }
    int count = 0;
    Node<T>* p = front;
    while (p)
    {
        p=p->next;
        count++;
    }

    return count;
}
#endif

测试代码：

#include "LinkedQueue.h"

int main()
{
    LinkedQueue<int> Q;
    std::cout << "Q is Empty? "<<Q.IsEmpty() << std::endl;
    Q.Add(1);
    Q.Add(2);
    Q.Add(3);
    Q.Add(4);
    Q.Add(5);
    Q.Add(6);
    Q.Add(7);
    Q.Add(8);
    std::cout << "Quantity of Q is " << Q.Quantity() << std::endl;
    std::cout << "Q is:" << std::endl;
    std::cout << Q << std::endl;
    int x;
    Q.Delete(x);
    std::cout << "The num deleted is " << x << std::endl;
    std::cout << "Quantity of Q is " << Q.Quantity() << std::endl;
    std::cout << "Q is:" << std::endl;
    std::cout << Q << std::endl;
    system("pause");
    return 0;
}

输出：