编程题实训-队列（转载）

第1关：基于循环链表的队列的基本操作
任务描述
本关任务：用带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（不设头指针）。实现该队列的入队出队以及判断队列是否为空操作。

编程要求
输入
多组数据，每组数据有两行。第一行为两个整数n和m，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），m表示出队序列B的元素数量（m个数依次连续出队，中间没有入队的情况）。第二行为序列A（空格分隔的n个整数）。当n和m都等于0时，输入结束。

输出
对应每组数据输出一行。每行包括m+1个整数，前m个数代表出队序列B的各个整数，最后一个整数表示队列是否为空，队列为空输出0，不为空输出1。整数之间用空格分隔。

#include<iostream>
using namespace std;
typedef struct QNode
{//队列的链式存储结构
    int data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
    QueuePtr rear;    //只设一个队尾指针
}LinkQueue;
int EmptyQueue(LinkQueue Q)
{//判断队列是否为空，空返回1，否则返回0
//队列只有一个头结点，即当头结点的指针域指向自己时，队列为空
/**************begin************/
    return Q.rear->next == Q.rear;//Q.rear->next->next == Q.rear->next;
 
    /**************end************/
}
void EnQueue(LinkQueue &Q,int e)
{//入队，插入元素e为Q的新的队尾元素
/**************begin************/
   QueuePtr p = new QNode;//申请新节点
    p->data = e;
    //注意rear一直指向队尾
    p->next = Q.rear->next;
    Q.rear ->next = p;
    Q.rear = p;
 
    /**************end************/
}
void DeQueue(LinkQueue &Q)
{//出队，输出Q的队头元素值，后将其删除
/**************begin************/
   QueuePtr p = Q.rear->next->next; //p指向队头元素
    cout<<p->data<<" ";
    if(p==Q.rear){
        Q.rear = Q.rear->next;
        Q.rear->next = p->next;
    }else{
        Q.rear->next->next = p->next;
    }
    delete p;
 
 
    /**************end************/
}
int main()
{
	int n,m;
	while(cin>>n>>m)
	{
		if(n==0&&m==0) break;
		LinkQueue Q;        //初始化一个带头结点的循环链表
		Q.rear=new QNode;
        Q.rear->next=Q.rear;
		while(n--)
		{
			int e;cin>>e;
			EnQueue(Q,e);
		}
		while(m--)
			DeQueue(Q);
		if(EmptyQueue(Q))
			cout<<"0"<<endl;
		else
			cout<<"1"<<endl;
	}
	return 0;
}

第2关：附加判定标志的循环队列的基本操作 
 这是一个因为队满和队空都是Q.rear==Q.front而产生的问题，因此需要额外加个判断条件。
        

任务描述
本关任务：假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag== 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。

编程要求
输入
多组数据，每组数据有两行。第一行为一个整数n，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），第二行为序列A（空格分隔的n个整数）。当n=0时，输入结束。

输出
对应每组数据输出一行。依次输出队列中所有的整数，每两个整数之间用空格分隔。

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OK 0
#define OVERFLOW -1
#define ERROR -2
typedef struct
{
	int *base;
	int front,rear,tag;
}SqQueue;
int InitQueue(SqQueue &Q)
{//构造一个空队列Q
	Q.base=new int[MAXSIZE];//为队列分配一个最大容量MAXSIZE的数组空间
	if(!Q.base) return OVERFLOW;//存储分配失败
	Q.front=Q.rear=0;//头尾指针置零，队列为空
	Q.tag=0;//标志初始化为0，队列为空
	return OK;
}
int EnQueue(SqQueue &Q,int e)
{//插入元素e为Q的新的队尾元素
/**************begin************/
    if((Q.tag == 1)&&(Q.rear == Q.front)) return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXSIZE;
    if(Q.rear == Q.front) Q.tag == 1;//如果满了，返回1
    return OK;
	/**************end************/
}
int DeQueue(SqQueue &Q)
{//删除Q的队头元素，用e返回其值
/**************begin************/
    if((Q.tag == 0)&&(Q.rear == Q.front)) return ERROR;
    int e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXSIZE;
    return e;
	/**************end************/
}
int main()
{
	int n;
	while(cin>>n)
	{
		if(n==0) break;
		SqQueue Q;
		InitQueue(Q);
		for(int i=0;i<n;i++)
		{
			int x;cin>>x;
			EnQueue(Q,x);
		}
		for(int i=0;i<n-1;i++)
			cout<<DeQueue(Q)<<" ";
		cout<<DeQueue(Q)<<endl;
	}
	return 0;
}

第3关：基于两端操作的循环队列的实现 
任务描述
本关任务：如果允许在循环队列的两端都可以进行插入和删除操作。构造一个循环队列，实现从队头入队，从队尾出队并输出。约定从队头入队时向下标小的方向发展，从队尾入队时则向下标大的方向发展。

编程要求
输入
多组数据，每组数据有两行。第一行为一个整数n，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），第二行为序列A（空格分隔的n个整数）。当n等于0时，输入结束。

输出
对应每组数据输出一行。依次输出队列中所有的整数，每两个整数之间用空格分隔。

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct
{
	int *base;
	int front;
  	int rear;
}SqQueue;
int InitQueue(SqQueue &Q)
{//构造一个空队列Q
	Q.base=new int[MAXSIZE];          //为队列分配一个最大容量为MAXSIZE的数组空间
	if(!Q.base) return OVERFLOW;            //存储分配失败
	Q.front=Q.rear=0;                  //头尾指针置零，队列为空
	return OK;
}
int EnQueue(SqQueue& Q,int e)
{//在Q的队头插入新元素e
/**************begin************/
    if(Q.rear == (Q.front - 1 + MAXSIZE)% MAXSIZE) return ERROR;
    Q.base[Q.front] = e;
    Q.front = (Q.front - 1 + MAXSIZE) % MAXSIZE;
    return OK;
	/**************end************/
}
int DeQueue(SqQueue &Q)
{//删除Q的队尾元素，用e返回其值
/**************begin************/
    if(Q.front == Q.rear) return ERROR;
    int e = Q.base[Q.rear];
    Q.rear = (Q.rear - 1 + MAXSIZE) % MAXSIZE;
    return e;
	/**************end************/
}
int main()
{
	int n;
	while(cin>>n&&n!=0)
	{
		SqQueue Q;
		InitQueue(Q);
		for(int i=0;i<n;i++)
		{
			int x;cin>>x;
			EnQueue(Q,x);
		}
		for(int i=0;i<n-1;i++)
			cout<<DeQueue(Q)<<" ";
		cout<<DeQueue(Q)<<endl;
	}
	return 0;
}