#include<iostream>
#include<cstdlib>
#define MAXSIZE 100
using namespace std;

#include<iostream>
#include<cstdlib>
using namespace std;

#include<iostream>
#include<cstdlib>
#define MAX 100 
using namespace std;

typedef struct Node
{
struct Node *Next;   //队列元素的节点连接 
int Element;
}MyNode;

typedef struct Queue
{
int *Array;
int Front,Rear;
}*MyQueue;

typedef struct Queue
{
int Array[MAX];
int Front;
int Rear;
} *CircleQueue; 

typedef struct Queue
{
Node *Front;          //Front和Rear连接着各自应有的节点 
Node *Rear; 
int Items;            //队列元素的个数,用于判断是否空队列,满队列 
}*PtrToQueue; 

MyQueue Create(void);    //创建一个队列 
int IsEmpty(MyQueue Q);  //检验是否为空栈 
void DeQueue(MyQueue Q); //出队 
void EnQueue(int X,MyQueue Q); //入队 
void GetQueueFront(MyQueue Q); //获取队头元素 
void GetQueueRear(MyQueue Q);  //获取队尾元素 

CircleQueue Create(void);  //创建一个队列 
int IsEmpty(CircleQueue Q); //是否为空 
int IsFull(CircleQueue Q);  //是否已满 
void EnQueue(CircleQueue Q,int X); //入列 
void DeQueue(CircleQueue Q);      //出列 
void GetQueueFront(CircleQueue Q); //获取队头元素 
void GetQueueRear(CircleQueue Q);  //获得队尾元素 

typedef PtrToQueue MyQueue;

int main()  //测试 
{
MyQueue Q=Create();
EnQueue(100,Q);
DeQueue(Q);
return 0;
}

int main()  //测试 
{
CircleQueue Q=Create();
EnQueue(Q,100);
    DeQueue(Q);
return 0;
}

MyQueue Create(void);  //创建一个队列 
void EnQueue(int X,MyQueue Q); //入队 
void DeQueue(MyQueue Q);       //出队 
int IsFull(MyQueue Q);         //判断是否满队 
int IsEmpty(MyQueue Q);        //判断是否为空队列 
void GetQueueFront(MyQueue Q);
//获得队头元素,当然,也可以获得队尾元素,这里交给你写了 

int IsEmpty(MyQueue Q)
{
return Q->Front==Q->Rear;  
//如果队头下标等于队尾下标,也就是空队列那么返回1,否则返回0 
}

int IsEmpty(CircleQueue Q)      
{
return (Q->Rear-1)==0;  //Q->Rear-1才是最后一个元素 
}

int main() //测试 
{
MyQueue Q=Create();
EnQueue(100,Q); 
DeQueue(Q);      
return 0;
}

void EnQueue(int X,MyQueue Q)
{
if(Q->Front==Q->Rear&&Q->Rear==0)  //如果是空队列 
{
Q->Array[Q->Front]=X;     //从头部入列
Q->Array[Q->Rear]=Q->Array[Q->Front];    
//空队列入队的话,队头也是队尾 
cout <<Q->Array[Q->Front] <<“已入列”
<<“入队后” ;
}
else        //如果不是空队列 
{
Q->Array[++Q->Rear]=X; //从尾部入列 
cout <<X <<“已入列” <<endl <<“入队后 ” ;  
 //提示 
}
GetQueueFront(Q);
GetQueueRear(Q);
cout <<endl ; 
}

int IsFull(CircleQueue Q)
{
return (Q->Rear-1-Q->Front)==MAX;  //通过队列个数判断是否为满 
}

MyQueue Create(void)
{
MyNode *NewNode;
MyQueue Q;
Q=(MyQueue)malloc(sizeof(struct Queue));  //为MyQueue类型的Q开辟内存 
if(Q==NULL)
   cout <<“空间不足! ” <<endl ;
Q->Front=(MyNode *)malloc(sizeof(MyNode)); //为Q的头节点开辟内存 
if(Q->Front==NULL)
   cout <<“空间不足! ” <<endl ;
Q->Rear=(MyNode *)malloc(sizeof(MyNode));//为Q的尾节点开辟内存
if(Q->Rear==NULL)
   cout <<“空间不足! ” <<endl ;
Q->Front=Q->Rear;   //一开始,头结点就是尾节点 
Q->Items=0;         //队列元素为0 
int a[8]={13,15,17,21,18,38,28,31};
for(int i=0;i<8;i++)
{
NewNode=(MyNode *)malloc(sizeof(MyNode));
   if(NewNode==NULL)
       cout <<“空间不足! ” <<endl ;
   NewNode->Element=a[i];  //赋值 
NewNode->Next=NULL;     //新开辟的节点总是尾节点 
if(Q->Items==0)         //如果入的是空队,先入头节点 
{
Q->Front=NewNode; //队头等于NewNode 
Q->Rear=NewNode;  //队尾也是NewNode 
cout <<Q->Front->Element <<“已入列 ” <<endl ;
Q->Items++; //入队后元素个数+1 
}
else          //如果入的不是空队 
{
   Q->Rear->Next=NewNode;  //从队尾进去 
   Q->Rear=Q->Rear->Next;  //NewNode成为新的队尾元素 
   cout <<Q->Rear->Element <<“已入列 ” <<endl
;
   Q->Items++;  //元素个数+1 
}
}
return Q;
}

void DeQueue(MyQueue Q)         
{
if(IsEmpty(Q))
   cout <<“队列为空不能出列 ” <<endl ;      
//如果是空队列不能出列 
else
   {
    Q->Array[Q->Front]=Q->Array[Q->Front++];
 //队头往后一个元素挪 
}
cout <<“出队后” ;     //提示 
GetQueueFront(Q);
GetQueueRear(Q);
}

void EnQueue(CircleQueue Q,int X)
{
if(IsFull(Q))
   cout <<“队列已满不能插入 ” <<endl ; 
else
{
if(IsEmpty(Q))  //空队列情况入队 
{
Q->Array[Q->Front]=X;
Q->Array[Q->Rear]=Q->Array[Q->Front];
Q->Rear=(Q->Rear+1)%MAX;//循环意义下的尾指针加1
}
else          //非空入列 
{
Q->Array[Q->Rear]=X;
Q->Rear=(Q->Rear+1)%MAX;     //循环意义下的尾指针加1
}
cout <<endl <<Q->Array[Q->Rear-1] <<“入队后”
<<endl ;
GetQueueFront(Q);
        GetQueueRear(Q);

}

void EnQueue(int X,MyQueue Q)
{
if(IsFull(Q))
   cout <<“队列已满不能插入! ” <<endl ;
MyNode *NewNode;
NewNode=(MyNode *)malloc(sizeof(MyNode));
if(NewNode==NULL)
   cout <<“空间不足! ” <<endl ;
NewNode->Element=X;
NewNode->Next=NULL;
if(Q->Items==0)         //如果入的是空队,先入头节点 
{
Q->Front=NewNode; //队头等于NewNode 
Q->Rear=NewNode;  //队尾也是NewNode 
cout <<Q->Front->Element <<“已入列 ” <<endl ;
Q->Items++; //入队后元素个数+1 
}
else          //如果入的不是空队 
{
   Q->Rear->Next=NewNode;  //从队尾进去 
   Q->Rear=Q->Rear->Next;  //NewNode成为新的队尾元素 
   cout <<Q->Rear->Element <<“已入列 ” <<endl
;
   Q->Items++;  //元素个数+1 
}
cout <<“入队后 ” ; 
GetQueueFront(Q);
}

MyQueue Create(void)
{
MyQueue Q;
Q->Front=Q->Rear=0;   //初始化队列 
int a[8]={18,19,11,13,25,26,30,14};
for(int i=0;i<8;i++)
{
if(i==0)   //一开始的先入队头 
{
Q->Array[Q->Front]=a[i];
Q->Array[Q->Rear]=Q->Array[Q->Front];
 //一开始队尾也是队头 
cout <<Q->Array[Q->Rear]<<“已入列 ” <<endl ;
 //提示 
}
else        //有了队头后就从队尾入队 
   {
Q->Array[++Q->Rear]=a[i]; //从尾部入列 
    cout <<Q->Array[Q->Rear]<<“已入列 ” <<endl
;//提示 
}
}
cout <<endl ;
GetQueueFront(Q);
GetQueueRear(Q);
cout <<endl ;
return Q;
}

void DeQueue(CircleQueue Q)
{
if(IsEmpty(Q))
   cout <<“队列为空不能出队 ” <<endl ;
else     //非空出列 
{
Q->Front=(Q->Front+1)%MAX;     //循环意义下的头指针加1
}
cout <<endl <<“出队后” <<endl ; 
GetQueueFront(Q);
    GetQueueRear(Q);
}

void DeQueue(MyQueue Q)
{
if(IsEmpty(Q))
   cout <<“空队列 !” <<endl ;
else
{
MyNode *Deletion; 
   Deletion=Q->Front;  //Deletion是方便释放头节点的内存 
   Q->Front=Q->Front->Next;  //队头的下一个元素成为新的队头 
   delete Deletion;          //释放
   Q->Items–;               //出队后,元素个数-1 
   if(Q->Items==0)
   Q->Rear=NULL;
   cout <<“出队后 ” ; 
   GetQueueFront(Q);
}
}

void GetQueueFront(MyQueue Q)
{
if(IsEmpty(Q))
   cout <<“空队列!” <<endl ;
else
   cout <<Q->Array[Q->Front] <<“为队头 ”
<<endl ; //Front就是队头 
}

void GetQueueFront(CircleQueue Q)
{
cout <<“队头为” <<Q->Array[Q->Front] <<endl
;

int IsFull(MyQueue Q)
{
return Q->Items==MAXSIZE;      
 //MAXSIZE根据需求定义,如果元素个数为MAXSIZE就返回1,否则返回0 
}

void GetQueueRear(MyQueue Q)
{
if(IsEmpty(Q))
   cout <<“空队列!” <<endl ;
else
   cout <<Q->Array[Q->Rear] <<“为队尾 ” <<endl
; //Rear就是队尾 
}

}

int IsEmpty(MyQueue Q)
{
return Q->Items==0;  //如果队列元素为0则返回1,否则返回0 
}

void GetQueueRear(CircleQueue Q)
{
cout <<“队尾为” <<Q->Array[Q->Rear-1] <<endl ;
  //Q->Rear才是队尾的下标 
}

void GetQueueFront(MyQueue Q)
{
if(IsEmpty(Q))
   cout <<“空队列 !” <<endl ;
else
   cout <<Q->Front->Element <<“为队头 ” <<endl
<<endl ; //输出队头元素 
}

CircleQueue Create(void)
{
int i,a[8]={8,9,11,7,12,15,14,18};
CircleQueue Q;
Q->Front=Q->Rear=0;
for(i=0;i<8;i++)
{
cout <<a[i] <<‘ ‘ ;
}
cout <<endl ;
for(i=0;i<8;i++)
{
if(i==0)      //非空入列 
{
Q->Array[Q->Front]=a[i]; //先给队头赋值 
Q->Array[Q->Rear]=Q->Array[Q->Front];
Q->Rear=(Q->Rear+1)%MAX;       //循环意义下的尾指针加1
}
else    
{
Q->Array[Q->Rear]=a[i];    
Q->Rear=(Q->Rear+1)%MAX;      //循环意义下的尾指针加1
}
}
GetQueueFront(Q);
    GetQueueRear(Q);
return Q;
}