数据结构库——链式队列的实现

1，StaticQueue 的对象在创建的时候，对于数据元素为类类型时，会多次调用元素类型的构造函数，影响效率，所以要实现链式队列；

  

2，队列的链式存储实现：

  

      

3，链式队列的设计要点：

       1，类模板，抽象父类 Queue 的直接子类；

       2，在内部使用链式结构实现元素的存储；

       3，只在链表的头部和尾部进行操作；

 

4，基于 LinkList 的队列 LinkQueue 的实现：

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

namespace DTLib
{

template < typename T >
class LinkQueue : public Queue<T>
{
protected:
　　 LinkList<T> m_list;

public:
    LinkQueue()
    {
　　 }

    void add(const T& e)     // O(n)  这里需要改进   每次插入都要从头到尾的插入，很耗时。用linuxList改进。
    {
        m_list.insert(e);
　　 }

    void remove()    // O(1)
    {
        if( m_list.length() > 0 )
        {
            m_list.remove(0);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No LinkQueue element to remove ...");
        }
　　 }

    T front() const    // O(1)
    {
        if( m_list.length() > 0 )
        {
            return m_list.get(0);   // 直接取，不对队列做操作
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current LinkQueue ...");
        }
　　 }

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

    void clear()   // O(n)
    {
        m_list.clear();
　　 }

    ~LinkQueue()
    {
        clear();
    }
};

}

5，基于 LinkList 实现链式队列：

       1，基于 LinkList 实现的链式队列插入和清空操作中时间复杂度为 O(n)，不高效；

6，队列链式存储实现的优化：

 

       1，基于双向循环链表实现，要基于头结点的前驱和后继指针，很经典，直接指向队头和队尾；

      

7，基于 Linux 内核链表实现链式队列：

 

       1，内核链表本身就是双向链表且能够通过结点指针相互连接，仅需要给结点指针加入值的存储空间构成新的结点就可以来作为真真的节点，但是头结点不用加值的存储空间；

       2，形象的来说就是除了头结点其它结点长出来了一部分；

8，基于 Linux 内核链表的队列 LinkQueue 实现：

#ifndef LINKQUEUE_H
#define LINKQUEUE_H

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

namespace DTLib
{

template < typename T >
class LinkQueue : public Queue<T>
{
protected:
    struct Node : public Object  // 定义内部使用的结点对象，不是结构体
    {
        list_head head;  // 链表头成员
        T value;
　　 };

    list_head m_header;
　　 int m_length;

public:
    LinkQueue()  // O(1)
    {
        m_length = 0;
        INIT_LIST_HEAD(&m_header);
　　 }

    void add(const T& e)   // O(1)
    {
        Node* node = new Node();

        if( node != NULL )
        {
            node->value = e;
            list_add_tail(&node->head, &m_header); // O(1)，将 node 插入链表尾部；
            m_length++;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No memory to add new element ...");
        }
　　 }

    void remove()   // O(1)
    {
        if( m_length > 0 )
        {
            list_head* toDel = m_header.next;
            list_del(toDel);  // 调用内核链表函数删除内核链表结点，但是这里仅仅是断了指针的连接，还有对象实体没有销毁 O(1)
            m_length--;
            //delete toDel;
            delete list_entry(toDel, Node, head);      
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No LinkQueue element to remove ...");
        }
　　 }

    T front() const    // O(1)
    {
        if( m_length > 0 )
        {
            return list_entry(m_header.next, Node, head)->value;   // 直接取，不对队列做操作；去头结点下一个结点的值
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current LinkQueue ...");
        }
　　 }

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

    void clear()     // O(n)
    {
        while( m_length > 0 )  // 队列中的每一个结点都出队列；
        {
            remove();
        }
　　 }

    ~LinkQueue()  // O(n)
    {
        clear();
    }
};

}

#endif // LINKQUEUE_H

9，LinkQueue 的测试代码：

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

using namespace std;
using namespace DTLib;

class Test : public Object
{
public:
    Test()
    {
        cout << "Test()" << endl;
　　 }

    ~Test()
    {
        cout << "~Test()" << endl;
    }
};

int main()
{
    LinkQueue<Test> lq;
　　 StaticQueue<Test, 10> sq;

    for(int i=0; i<10; i++)
    {
        //lq.add(i);
　　 }

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

    return 0;
}

10，小结：

       1，StaticQueue 在初始化时可能多次调用元素类型的构造函数；

       2，LinkList 的组合使用能够实现队列的功能，但是不够高效；

       3，LinkQueue 的最终实现组合使用了 Linux 内核链表；

       4，LinkQueue 中入队和出队操作可以再常量时间内完成；