introduction to algorithms 菜鸟笔记 queue

//author:yydrewdrew

 

#define ERROR -1

 

template <class T>
struct snode
{ 
 snode *next;
 T value;
};

 

 

template <class T>
class queue
{
public:
 explicit queue();
 void enqueue(const T &t);
 T dequeue();
 queue(const queue<T> &obj);
 bool empty()const;
 void clear();
 queue<T> &operator = (const queue<T> &obj);
 bool operator == (const queue<T> &obj)const;
 bool operator != (const queue<T> &obj)const;
 virtual ~queue();
private:
 void Destory();
 size_t number;
 snode<T> *head;
 snode<T> *tail;
};

template<class T>
queue<T> &queue<T>::operator = (const queue<T> &obj)
{
 if (this != &obj)
 {
  if (obj.tail == NULL)
  {
   Destory();
   tail = NULL;
   number = 0;
  }
  else
  {
   snode<T> *p = new snode<T>;
   snode<T> *p_ = obj.tail;
   p->value = p_->value;
   p->next = NULL;
   snode<T> *_tail = p;
   while (p_->next != NULL)
   {
    p_ = p_->next;
    p->next = new snode<T>;
    p->next->value = p_->value;
    p->next->next = NULL;
    p = p->next;
   }
   Destory();
   tail = _tail;
   number = obj.number;
  }
 }
 return *this;
}

template <class T>
queue<T>::queue<T>():number(0),head(NULL),tail(NULL){}

template<class T>
bool queue<T>::operator == (const queue<T> &obj)const
{
 if (number != obj.number)
 {
  return false;
 }
 bool is = true;
 snode<T> *p = tail;
 snode<T> *_p = obj.tail;
 while (p != NULL && _p != NULL)
 {
  if (p->value != _p->value)
  {
   is = false;
   break;
  }
  p = p->next;
  _p = _p->next;
 }
 return is;
}

template<class T>
void queue<T>::Destory()
{
 while (tail != NULL)
 {
  snode<T> *_p = tail->next;
  delete tail;
  tail = _p;
 }
 number = 0;
}

template<class T>
bool queue<T>::operator != (const queue<T> &obj)const
{
 if (number != obj.number)
 {
  return true;
 }
 bool is = false;
 snode<T> *p = tail;
 snode<T> *_p = obj.tail;
 while (p != NULL && _p != NULL)
 {
  if (p->value != _p->value)
  {
   is = true;
   break;
  }
  p = p->next;
  _p = _p->next;
 }
 return is;
}

template <class T>
void queue<T>::enqueue(const T& t)
{
 if (number == 0)
 {
  head = new snode<T>;
  head->value = t;
  head->next = NULL;
  tail = head;
  ++number;
  return;
 }
 snode<T> *ptem = new snode<T>;
 ptem->next = NULL;
 ptem->value = t;
 head->next = ptem;
 ++number;
 head = ptem;
}

template <class T>
T queue<T>::dequeue()
{
 if (number == 0)
 {
  throw ERROR;
 }
 snode<T> *p_tem = tail;
 tail = tail->next;
 T _t = p_tem->value;
 delete p_tem;
 --number;
 return _t;
}

template<class T>
queue<T>::~queue<T>()
{
 Destory();
}

template<class T>
queue<T>::queue<T>(const queue& obj)
{
 if (obj.tail == NULL)
 {
  tail = NULL;
  head = NULL;
  number = 0;
 }
 else
 {
  snode<T> *p = new snode<T>;
  snode<T> *p_ = obj.tail;
  p->value = p_->value;
  p->next = NULL;
  tail = p;
  number = obj.number;
  while (p_->next != NULL)
  {
   p_ = p_->next;
   p->next = new snode<T>;
   p->next->value = p_->value;
   p->next->next = NULL;
   p = p->next;
  }
 }
}

template <class T>
bool queue<T>::empty()const
{
 return (number == 0);
}

template<class T>
void queue<T>::clear()
{
 Destory();
}