数据结构 笔记：队列的概念及实现（上）

队列是一种特殊的线性表

队列仅能在线性表的两端进行操作

-队头（Front）：取出数据元素的一端

-队尾（Rear）：插入数据元素的一端

队列的特性

-先进先出

队列的操作

-创建队列

-销毁队列（Queue()）

-清空队列（~Queue()）

-进队列（add()）

-出队列（remove()）

-获取对头元素（front()）

-获取队列的长度（length()）

template <typename T>
class Queue :public Object
{
public:
    virtual void add(const T& e) = 0;
    virtual void remove() = 0;
    virtual T front() const = 0;
    virtual void clear() = 0;
    virtual int length() const = 0;

};

StaticQueue设计要点

-类模板

·使用原生数组作为队列的存储空间

·使用模板参数决定队列的最大容量

template <typename T, int N>
class StaticQueue : public Queue<T>
{
protected:
    T m_space[N];
    int m_front;
    int m_rear;
    int m_length;
public:
    StaticQueue()
    {
        m_front = 0;
        m_rear = 0;
        m_length = 0;
    }

    int capacity() const
    {
        return N;
    }
    void add(const T &e)
    {
        if(m_length < N)
        {
            m_space[m_rear + 1] = e;
            m_rear = (m_rear + 1) % N;
            m_length++;
        }
        else
        {
            //抛出异常
        }
    }

    void remove()
    {
        if(m_length > 0)
        {
            m_front = (m_front + 1) % N;
            m_length--;
        }
        else
        {
            //抛出异常
        }

    }

    T front() const
    {
        if(m_length > 0)
        {
            return m_space[m_front];
        }
        else
        {
            //抛出异常
        }
    }

    void clear()
    {
        m_front = 0;
        m_rear = 0;
        m_length = 0;
    }

    int length() const
    {
        return m_length;
    }

};

StaticQueue实现要点（循环计数法）

-关键操作

·进队列：m_space[m_rear] = e;m_rear = (m_rear + 1) % N;

·出队列：m_front = (m_front + 1)% N;

-队列的状态

·队空：(m_length == 0) && (m_front == m_rear)

·队满：(m_length == N)&&(m_front == m_rear)

总结：

队列是一种特殊的线性表，具有先进先出的特性

-队列值允许在线性表的两端进行操作，一端进，一端出

-StaticQueue使用原生数组作为内部存储空间

-StaticQueue的最大容量由模板参数决定

-StaticQueue采用循环计数法提高队列操作的效率