模板類的練習——隊列

隊列的練習，單鏈隊列、循環隊列以及隊列的各種基本操作。
#pragma once
#include <stdlib.h>
#include <malloc.h>
#define MAXQSIZE 10

template<class T>
class CQueue
{
public :
 CQueue();
 ~CQueue();
 //----------單鏈隊列-------隊列的鏈式存儲結構
 typedef  struct _tagQNode
 {
  T data;
  struct _tagQNode* next;
 }QNode,*QueuePtr;

 static struct _tagQueue
 {
  QueuePtr front; //隊頭指針
  QueuePtr rear; //隊尾指針
 };
 //----------循環隊列-------隊列的順序存儲結構
 static struct _tagSqQueue
 {
  T* base;
  int front;
  int rear;
 };

private:
 typedef _tagQueue LinkQueue,*LQueuePtr;
 typedef _tagSqQueue SqQueue;

public:
 // 初始化單鏈隊列
 bool InitQueue(LinkQueue& q);
 void DestroyQueue(LinkQueue& q);
 void ClearQueue(LinkQueue& q);
 int  QueueEmpty(LinkQueue q);
 int  QueueLength(LinkQueue q);
 T GetHead(LinkQueue q);
 T GetRear(LinkQueue q);
 bool EnQueue(LinkQueue& q,T e);
 bool DeQueue(LinkQueue& q,T& e);
 //有待完成
 bool QueueTraverse(LinkQueue& q);
 //初始化循環隊列
 bool InitSqQueue(SqQueue& q);
 void DestroySqQueue(SqQueue& q);
 void ClearSqQueue(SqQueue& q);
 int  SqQueueEmpty(SqQueue q);
 int  SqQueueLength(SqQueue q);
 T GetSqQueueHead(SqQueue q);
 T GetSqQueueRear(SqQueue q);
 bool EnSqQueue(SqQueue& q,T e);
 bool DeSqQueue(SqQueue& q,T& e);
 //有待完成
 bool SqQueueTraverse(SqQueue& q);
};

template<typename T>
CQueue<T>::CQueue()
{
}
template<typename T>
CQueue<T>::~CQueue()
{
}
template<class T>
bool CQueue<T>::InitQueue(LinkQueue& q)
{
 q.front = q.rear = new QNode;
 if(q.front == NULL)
  return false;
 q.front->next = NULL;
 return true;
}
template<class T>
bool CQueue<T>::InitSqQueue(SqQueue& q)
{
 q.base = new T[MAXQSIZE];
 if(q.base == NULL)
  return false;
 q.front = q.rear = 0;
 return true;
}
template<class T>
void CQueue<T>::DestroyQueue(LinkQueue& q)
{
 while(q.front)
 {
  q.rear = q.front -> next;
  free(q.front);
  q.front = q.rear;
 }
}
template<class T>
void CQueue<T>::DestroySqQueue(SqQueue& q)
{
 if( q.base != NULL)
  delete[] q.base;
}

template<class T>
void CQueue<T>::ClearQueue(LinkQueue& q)
{
 q.front = q.rear = NULL;
}
template<class T>
int CQueue<T>::QueueEmpty(LinkQueue q)
{
 if(q.front -> next !=null)
  return 0;
 return 1;
}
template<class T>
int CQueue<T>::SqQueueEmpty(SqQueue q)
{
 if(q.front != q.rear)
  return 0;
 return 1;
}
template<class T>
int CQueue<T>::SqQueueLength(SqQueue q)
{
 return (q.rear - q.front +MAXQSIZE ) % MAXQSIZE;
}
template<class T>
T CQueue<T>::GetHead(LinkQueue q)
{
 T e;
 e = q.front -> next->data;
 return e;
}
template<class T>
T CQueue<T>::GetSqQueueHead(SqQueue q)
{
 T e;
 e = *(q.base+q.front);
 return e;
}
template<class T>
T CQueue<T>::GetSqQueueRear(SqQueue q)
{
 T e;
 e = *(q.base+q.rear-1);
 return e;
}
template<class T>
T CQueue<T>::GetRear(LinkQueue q)
{
 T e=0;
 e = q.rear->data;
 return e;
}
template<class T>
bool CQueue<T>::EnQueue(LinkQueue& q,T e)
{
 QueuePtr tmp = new QNode;
 if(tmp == NULL)
  return false;
 tmp->data = e;
 tmp->next = NULL;
 
 q.rear->next = tmp;
 q.rear = tmp;
 return true;
}
template<class T>
bool CQueue<T>::EnSqQueue(SqQueue& q,T e)
{
 if((q.rear + 1)% MAXQSIZE == q.front)
  return false;
 *(q.base + q.rear ) = e;
 q.rear = (q.rear + 1) % MAXQSIZE;
 return true;
}

template<class T>
bool CQueue<T>::DeQueue(LinkQueue& q,T& e)
{
 QueuePtr temp = new QNode;
 if(temp == NULL)
 {
  return false;
 }
 else
 {
  temp = q.front -> next;
  e = temp -> data;
  q.front->next =temp->next;
  delete temp;
 }
 return true;
}
template<class T>
bool CQueue<T>::DeSqQueue(SqQueue& q,T& e)
{
 if( q.front == q.rear )
  return false;
 e = * (q.base + q.front);
 q.front = (q.front + 1)% MAXQSIZE;
 return true;
}

/*
******************************************************
test
******************************************************
*/
int _tmain(int argc, _TCHAR* argv[])
{
 CQueue<int>::_tagQueue q;
 CQueue<int> queue;
 queue.InitQueue(q);
 queue.EnQueue(q,1);
 queue.EnQueue(q,2);
 queue.EnQueue(q,3);
 queue.EnQueue(q,4);
 queue.EnQueue(q,5);
 int e=0;
 queue.DeQueue(q,e);
 cout<<queue.GetHead(q)<<endl;
 cout<<queue.GetRear(q)<<endl;

 queue.DestroyQueue(q);
 cout<<"循環隊列"<<endl;
 CQueue<int>::_tagSqQueue sq;
 queue.InitSqQueue(sq);
 queue.EnSqQueue(sq,1);
 queue.EnSqQueue(sq,2);
 queue.EnSqQueue(sq,3);
 queue.EnSqQueue(sq,4);
 queue.EnSqQueue(sq,5);

 queue.DeSqQueue(sq,e);
 cout<<e<<endl;
 queue.DeSqQueue(sq,e);
 cout<<e<<endl;

 queue.EnSqQueue(sq,6);
 queue.EnSqQueue(sq,7);
 queue.EnSqQueue(sq,8);
 queue.EnSqQueue(sq,9);
 queue.DeSqQueue(sq,e);
 queue.DeSqQueue(sq,e);
 cout<<queue.GetSqQueueHead(sq)<<endl;
 cout<<queue.GetSqQueueRear(sq)<<endl;
 queue.DestroySqQueue(sq);
}