数据结构库——顺序队列的实现

1，队列本质：

       1，队列是一种特殊的线性表（对比前面的栈）；

       2，队列仅能在线性表的两端进行操作（生活中的排队）：

              1，队头（Font）：取出数据元素的一端；

              2，队尾（Rear）：插入数据元素的一端；

             

2，队列特性（唯一特性）：

  

       1，先进先出（First In First Out）；

      

3，队列的操作（创销进出获长清）：

       1，创建队列（Queue()）：

       2，销毁队列（~Queue()）；

       3，进队列（add()）；

       4，出队列（remove()）；

       5，获取队列头元素（front()）（先来先服务，只提供队头获取方式）；

       6，获取队列的长度（length()）；

       7，清空队列（clear()）；

      

4，队列的实现：

  

      

5，队列的顺序实现：

  

      

6，StaticQueue 设计要点：

       1，类模板：

              1，使用原生数组作为队列的存储空间；

              2，使用模板参数决定队列的最大容量；

                

 

 

7，StaticQueue 实现要点（循环计数法，为了高效）：

       1，关键操作：

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

              2，出队列：m_front = (m_front + 1）% N;

       2，队列的状态：

              1，队空：(m_length == 0) && (m_front == m_rear);

              2，队满：(m_length == N) && (m_front == m_rear);

 

8，基于顺序存储结构的队列 StaticQueue 实现：

#ifndef STATICQUEUE_H
#define STATICQUEUE_H

#include "Queue.h"
#include "Exception.h"

namespace DTLib
{

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;// 由于队列的为空的条件可知，这里设置为 0 也可以表示队列为空；
        m_rear = 0;
        m_length = 0;
　　 }

    int capacity() const
    {
        return N;
　　 }

    void add(const T& e)    // O(1)
    {
        if( m_length < N )
        {
            m_space[m_rear] = e;   // 行为时刻作用于类的属性
            m_rear = (m_rear + 1) % N;   // 循环计数法，可以不用纠结于在那个位置进队列，也就是不用移动元素，很是提高效率；
            m_length++;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No space in current StaticQueue ...");
        }
　　 }

    void remove()  // O(1)
    {
        if( m_length > 0 )
        {
            m_front = (m_front + 1) % N;  // 循环计数法，可以不用纠结于在哪//里出队列，也不用移动元素，很是高效；
            m_length--;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current queue ...");
        }
　　 }

    T front() const   // O(1)
    {
        if( m_length > 0 )
        {
            return m_space[m_front];   // 直接取，不对队列做操作
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current queue ...");
        }
　　 }

    int length() const    // O(1)
    {
        return m_length;
　　 }

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

    ~StaticQueue()
    {
        clear();
    }
};

}

#endif // STATICQUEUE_H

 

9，StaticQueue 检测代码：

#include <iostream>
#include "StaticQueue.h"

using namespace std;
using namespace DTLib;

int main()
{
　　 StaticQueue<int, 5> queue;

    for(int i=0; i<5; i++)
    {
        queue.add(i);
　　 }

    while( queue.length() > 0 )
    {
        cout << queue.front() << endl;
        queue.remove();
　　 }

    return 0;
} 

             

10，小结：

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

       2，队列只允许在线性表的两端进行操作，一端进，一端出；

       3，StaticQueue 使用原生数组作为内部存储空间；

       4，StaticQueue 的最大容量由模板参数决定；

              1，StaticQueue 是一种容器；

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