队列

    1.采用链式存储实现队列的初始化、入队、出队操作。
    2.采用顺序存储实现循环队列的初始化、入队、出队操作。

//Queue.h文件

#include <iostream.h>
#ifndef QUEUE_H
#define QUEUE_H

typedef int ElemType;
#define MAXSIZE 20

/*[Begin]链式队列的结构体定义------------------------------------------------*/
typedef struct QueueNode
{
 ElemType data;
 struct QueueNode *next;
}QueueNode;

typedef struct
{
 QueueNode *front,*rear;
}LinkQueue,*PLinkQueue;
/*[End]链式队列的结构体定义--------------------------------------------------*/

/*[Begin]队列的结构体定义----------------------------------------------------*/
typedef struct
{
 ElemType data[MAXSIZE];
 int front,rear;
}SeqQueue,*PSeqQueue;
/*[End]队列的结构体定义------------------------------------------------------*/

/*[Begin]链式队列------------------------------------------------------------*/

/*初始化链式队列*/
PLinkQueue Init_LinkQueue()
{
 PLinkQueue _PLinkQueue = new LinkQueue();
 if(_PLinkQueue)
 {
  _PLinkQueue->front = NULL;
  _PLinkQueue->rear = NULL;
 }
 return _PLinkQueue;
}

/*销毁链式队列*/
void Destroy_LinkQueue(PLinkQueue _PLinkQueue)
{
 QueueNode *_QueueNode;
 if(_PLinkQueue)
 {
  while(_PLinkQueue->front)
  {
   _QueueNode = _PLinkQueue->front;
   _PLinkQueue->front = _PLinkQueue->front->next;
   delete _QueueNode;
  }
  delete _PLinkQueue;
 }
 _PLinkQueue = NULL;
}

/*判断队列是否为空，为空则返回True，否则返回False*/
bool isEmpty_LinkQueue(PLinkQueue _PLinkQueue)
{
 if(_PLinkQueue && _PLinkQueue->front == NULL && _PLinkQueue->rear == NULL)
 {return true;}
 else
 {return false;}
}

/*入队，成功返回True，否则返回False*/
bool Enqueue_LinkQueue(PLinkQueue _PLinkQueue,ElemType _elem)
{
 QueueNode *_QueueNode = new QueueNode();
 if(!_PLinkQueue)
 {
  cout<<"内存溢出！"<<endl;
  return false;
 }
 else
 {
  _QueueNode->data = _elem;
  _QueueNode->next = NULL;
  //如果为空队，则让头尾指针都指向新插入的结点
  if(isEmpty_LinkQueue(_PLinkQueue))
  {_PLinkQueue->rear = _PLinkQueue->front = _QueueNode;}
  else
  {
   _PLinkQueue->rear->next = _QueueNode;
   _PLinkQueue->rear = _QueueNode;
  }
  return true;
 } 
}

/*出队，成功返回True，否则返回False*/
bool Dnqueue_LinkQueue(PLinkQueue _PLinkQueue,ElemType *_elem)
{
 QueueNode *_QueueNode = new QueueNode();
 if(!_PLinkQueue)
 {
  cout<<"内存溢出！"<<endl;
  return false;
 }
 else
 {
  if(isEmpty_LinkQueue(_PLinkQueue))
  {
   cout<<"队列为空！"<<endl;
   return false;
  }
  else
  {
   *_elem = _PLinkQueue->front->data;
   _QueueNode = _PLinkQueue->front;
   _PLinkQueue->front = _PLinkQueue->front->next;
   delete _QueueNode;
   if(_PLinkQueue->front == NULL)
   {_PLinkQueue->rear = NULL;}
   return true;
  }
 }
}

/*读取队头元素，成功返回True，否则返回False*/
bool GetFront_LinkQueue(PLinkQueue _PLinkQueue,ElemType *_elem)
{
 if(!_PLinkQueue)
 {
  cout<<"内存溢出！"<<endl;
  return false;
 }
 else
 {
  if(isEmpty_LinkQueue(_PLinkQueue))
  {
   cout<<"队列为空！"<<endl;
   return false;
  }
  else
  {
   *_elem = _PLinkQueue->front->data;
   return true;
  }
 }
}

/*[End]链式队列--------------------------------------------------------------*/

/*[Begin]循环队列------------------------------------------------------------*/

/*初始化循环队列*/
PSeqQueue Init_SeqQueue()
{
 PSeqQueue _PSeqQueue;
 _PSeqQueue = new SeqQueue();
 if(_PSeqQueue)
 {
  _PSeqQueue->front = 0;
  _PSeqQueue->rear = 0;
 }
 return _PSeqQueue;
}

/*销毁循环队列*/
void Destroy_SeqQueue(PSeqQueue _PSeqQueue)
{
 if(_PSeqQueue)
 {
  delete _PSeqQueue;
 }
 _PSeqQueue = NULL;
}

/*判断队列是否为空，是则返回True，否则返回False*/
bool isEmpty_SeqQueue(PSeqQueue _PSeqQueue)
{
 if(_PSeqQueue && _PSeqQueue->front == _PSeqQueue->rear)
 {return true;}
 else
 {return false;}
}

/*入队，成功返回True，否则返回False*/
bool Enqueue_SeqQueue(PSeqQueue _PSeqQueue,ElemType _elem)
{
 if((_PSeqQueue->rear + 1) % MAXSIZE == _PSeqQueue->front)
 {
  cout<<"对列已满！"<<endl;
  return false;
 }
 else
 {
  _PSeqQueue->rear = (_PSeqQueue->rear + 1) % MAXSIZE;
  _PSeqQueue->data[_PSeqQueue->rear] = _elem;
  return true;
 } 
}

/*出队，将出队元素使用_elem保存。成功返回True，否则返回False*/
bool Dnqueue_SeqQueue(PSeqQueue _PSeqQueue,ElemType *_elem)
{
 if(isEmpty_SeqQueue(_PSeqQueue))
 {
  cout<<"队列为空！"<<endl;
  return false;
 }
 else
 {
  _PSeqQueue->front = (_PSeqQueue->front + 1) % MAXSIZE;
  *_elem = _PSeqQueue->data[_PSeqQueue->front];
  return true;
 }
}

/*读取对头元素，将出队元素使用_elem保存。成功返回True，否则返回False*/
bool GetFront_SeqQueue(PSeqQueue _PSeqQueue,ElemType *_elem)
{
 if(isEmpty_SeqQueue(_PSeqQueue))
 {
  cout<<"队列为空！"<<endl;
  return false;
 }
 else
 {
  *_elem = _PSeqQueue->data[(_PSeqQueue->front + 1) % MAXSIZE];
  return true;
 }
}
/*[End]循环队列--------------------------------------------------------------*/

#endif

//MainFile.cpp文件

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

void main()
{
 ElemType Input = 0;    //定义保存输入的变量
 ElemType _elem = 0;    //定义保存返回指

 /*[Begin]链式队列------------------------------------------------------*/
 PLinkQueue _PLinkQueue;
 
 _PLinkQueue = Init_LinkQueue();  //初始化队列

 /*[Begin]输入元素，并压入队列中-----------------------------------*/ 
 cout<<"建立链式队列，以输入 0 结束："<<endl;
 cout<<"=========================================="<<endl;
 cout<<"Please Input Number：";
 cin>>Input;
 while(Input != 0)
 {
  if(Enqueue_LinkQueue(_PLinkQueue,Input) == false) //调用入队函数，返回False则结束循环
  {break;}
  cout<<"Please Input Number：";
  cin>>Input;
 }
 cout<<"=========================================="<<endl;
 /*[End]输入元素，并压入队列中-------------------------------------*/
 
 /*[Begin]将元素出队，并输出---------------------------------------*/
 while(_PLinkQueue->front)
 {
  if(Dnqueue_LinkQueue(_PLinkQueue,&_elem) == false) //调用出队函数，返回False则结束循环
  {break;}
  cout<<"Output The Number："<<_elem<<endl;
 }
 cout<<"=========================================="<<endl;
 /*[End]将元素出队，并输出-----------------------------------------*/

 Destroy_LinkQueue(_PLinkQueue);
 /*[End]链式队列--------------------------------------------------------*/

 cout<<endl;

 /*[Begin]循环队列------------------------------------------------------*/
 PSeqQueue _PSeqQueue;
 _PSeqQueue = Init_SeqQueue();

 /*[Begin]输入元素，并压入队列中-----------------------------------*/ 
 cout<<"建立循环队列，以输入 0 结束："<<endl;
 cout<<"=========================================="<<endl;
 cout<<"Please Input Number：";
 cin>>Input;
 while(Input != 0)
 {
  if(Enqueue_SeqQueue(_PSeqQueue,Input) == false) //调用入队函数，返回False则结束循环
  {break;}
  cout<<"Please Input Number：";
  cin>>Input;
 }
 cout<<"=========================================="<<endl;
 /*[End]输入元素，并压入队列中-------------------------------------*/

 /*[Begin]将元素出队，并输出---------------------------------------*/
 while(isEmpty_SeqQueue(_PSeqQueue) == false)
 {
  if(Dnqueue_SeqQueue(_PSeqQueue,&_elem) == false) //调用出队函数，返回False则结束循环
  {break;}
  cout<<"Output The Number："<<_elem<<endl;
 }
 cout<<"=========================================="<<endl;
 /*[End]将元素出队，并输出-----------------------------------------*/

 Destroy_SeqQueue(_PSeqQueue);
 /*[End]循环队列--------------------------------------------------------*/
}