实现了两个普通的队列，一个优先权队列

       C++ 基础内容， 不值一提

Author：Jacky Wu       2006-5-5

引用该文章，必须注明其出处              http://blog.csdn.net/imwkj

 

 两个普通的队列，还有一个是利用链表队列实现的优先级队列，没什么好说的，使用了简单的继承，看代码就明白了

#ifndef QUEUE_H_

#define QUEUE_H_

 

#include "Chain.h"

 

#include <cassert>

#include <cstddef>

#include <stdexcept>

 

//固定事务数的队列

//用数组实现

template <class Type>

class FixQueue {

public:

   FixQueue( size_t sz );

   virtual ~FixQueue();

  

   bool EnQueue( const Type& item);

   Type DeQueue();

   Type GetFront();

   void MakeEmpty() { m_ifront = m_irear = 0; }

   bool IsEmpty() const { return  m_ifront == m_irear; }

   bool IsFull() const { return (m_irear+1)%m_uiMaxSize == m_ifront; }

   size_t Length() const { return (m_irear+m_uiMaxSize-m_ifront)%m_uiMaxSize; }

private:

   int m_irear, m_ifront;

   Type* m_pElement;

   size_t m_uiMaxSize;

};

 

//--------------------------------------

//FixQueue template implementation

//

template <class Type>

FixQueue<Type>::FixQueue( size_t sz = 15) : m_uiMaxSize(sz)

{

   m_pElement = new Type[m_uiMaxSize];

   assert( m_pElement != 0);   //其实这样做没有作用

   m_ifront = m_irear = 0; 

}

 

template <class Type>

FixQueue<Type>::~FixQueue()

{

   delete []m_pElement;

}

 

template <class Type>

bool FixQueue<Type>::EnQueue( const Type& item )

{

   //队列不满则加入元素

   if(IsFull()) return false;

   m_irear = (m_irear+1) % m_uiMaxSize; //计算队尾值

   m_pElement[m_irear] = item;

   return true;

}

 

template <class Type>

Type FixQueue<Type>::DeQueue()

{

   if(IsEmpty())

   {

      MakeEmpty();

      throw std::out_of_range("Out Of bounds of Queue!/n");

   }

   else

   {

      m_ifront = (m_ifront+1) % m_uiMaxSize;

      return m_pElement[m_ifront];  

   }

}

 

template <class Type>

Type FixQueue<Type>::GetFront()

{

   //返回队列头元素的值

   if(IsEmpty())

   {

      MakeEmpty();

      throw std::out_of_range("Out Of bounds of Queue!/n");

   }

   else

   {

      return m_pElement[(m_ifront+1) % m_uiMaxSize];

   } 

}

 

//FixQueue Over!

 

//ChainQueue

//链式队列，虽然链式队列从抽象意义上来说"is a Chain"

//但是仔细分析，很容易发现链式队列只不过是能够在"链头删除元素"，"链尾添加元素"的普通链表

//更好的表示是： 链式队列"has a general Chain for specific use"

template <class Type>

class ChainQueue {

public:

   ChainQueue();

   virtual ~ChainQueue();

  

   virtual void EnQueue( const Type& item);

   virtual Type DeQueue();

   Type GetFront();

   void MakeEmpty();

   bool IsEmpty() const;

   size_t Length() const ;

 

private:

   Chain<Type> chain;

};

 

 

template <class Type>

ChainQueue<Type>::ChainQueue() {}

 

template <class Type>

ChainQueue<Type>::~ChainQueue() {}

template <class Type>

void ChainQueue<Type>::EnQueue( const Type& item)

{

   //新加元素

   try

   {

      chain.Appen(item);

   }

   catch (...)

   { throw; }

}

 

template <class Type>

Type ChainQueue<Type>::DeQueue()

{

   Type tmp;

   try

   {

      chain.Delete(1,tmp);

   }

   catch(...)

   {

      throw;

   }

   return tmp;

}

 

template <class Type>

Type ChainQueue<Type>::GetFront()

{

   Type tmp;

   if(!chain.Find(1,tmp)) throw std::out_of_range("Out Of bounds of Queue!/n");

   return tmp;

}

 

template <class Type>

void ChainQueue<Type>::MakeEmpty()

{

   chain.Erase();

}

 

template <class Type>

bool ChainQueue<Type>::IsEmpty() const

{

   return (chain.Length() == 0);

}

 

template <class Type>

size_t ChainQueue<Type>::Length() const

{

   return (size_t)chain.Length();

}

 

 

//============================================================

//PRQueue 实现一个按优先权重操作的队列

//显然，无需重新实现完整的优先权队列

//优先权队列只不过是一个特殊的队列罢了，优先级队列插入元素方式不同，

//要overwrite EnQueue();

//这里采用继承链式队列（考虑到元素插入的效率因素，链表划算）

//一个更好的方法是利用交叉链表实现优先级队列，优先级别为行列表，同优先级的任务放到列链表中，这里只是重新实现按权重插入元素

//=============================================================

//定义一个带优先权的结构

template <class Type>

typedef struct PRItem

{

   int priority;   //优先权

   Type item;      //元

  

   //只需要重载一个 <=就行了，这样刚好能够实现

   //1：先按照优先级处理

   //2：同优先级的FIFO方式处理

   bool operator<=( const PRItem& item) {

      return priority <= item.priority;

   }

};

 

 

template <class Type>

class PRQueue : public ChainQueue< PRItem<Type> > //郁闷，模板中模板类型

{

  

public:

   PRQueue();

   ~PRQueue();

   void EnQueue( const PRItem<Type>& item)        //overwrite

   {

      typedef PRItem<Type> PRITEM;

 

      typename Chain<PRITEM>::iterator iter = Chain<PRITEM>::chain.begin();

      int x=1;

      //按优先权插入寻找插入位置

      while(iter != Chain<PRITEM>::chain.end() && iter.current() <= item)

      {

         x++;

         iter++;

      }

     

      Chain<PRITEM>::chain.Insert(x, item);

   }

  

   void EnQueue( const Type& item, int priority)     //overload

   {

      PRItem<Type> tmp;

      tmp.item = item;

      tmp.priority = priority;

      EnQueue(tmp);     

   }

  

};

 

 

#endif /*QUEUE_H_*/