第三十七课 队列的概念及实现（下）

 

添加LinkQueue.h文件：

#ifndef LINKQUEUE_H
#define LINKQUEUE_H

#include "Queue.h"
#include "LinkList.h"
#include "Exception.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)
    {
       m_list.insert(e);
    }

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

    T front() const  // O(1)
    {
        if( m_list.length() > 0 )
        {
            return m_list.get(0);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current queue...");
        }
    }

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

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

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

}

#endif // LINKQUEUE_H

测试程序如下：

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

using namespace std;
using namespace DTLib;


int main()
{
    LinkQueue<int> lq;

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

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

        lq.remove();
    }

    return 0;
}

结果如下：

 用LinkList实现链式队列时，插入操作的时间复杂度为O(n)，这是很低效的。

 修改LinkQueue.h：

#ifndef LINKQUEUE_H
#define LINKQUEUE_H

#include "Queue.h"
#include "LinuxList.h"
#include "Exception.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)

           m_length++;
       }
       else
       {
           THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create Node object...");
       }
    }

    void remove()  // O(1)
    {
        if( m_length > 0 )
        {
            list_head* toDel = m_header.next;

            list_del(toDel);  // O(1)

            m_length--;

            delete list_entry(toDel, Node, head);
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No element in current queue...");
        }
    }

    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 queue...");
        }
    }

    void clear()   // O(n)
    {
        while ( m_length > 0 )
        {
            remove();
        }
    }

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

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

}

#endif // LINKQUEUE_H

如队列的操作的时间复杂度变成了O(1)。

测试程序如下：

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

using namespace std;
using namespace DTLib;


int main()
{
    LinkQueue<int> lq;

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

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

        lq.remove();
    }

    return 0;
}

结果如下：

测试程序2：

#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> queue;

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

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

        lq.remove();
    }

    return 0;
}

结果如下：

这体现了顺序队列的缺陷。而链式队列不存在这个问题。

小结：