链队的实现

 拷贝下面的代码，按要求完成链式队列的QueueEmpty，QueueLength，QueueEmpty，EnQueue和DeQueue操作，其他地方不得改动。

/***链队的基本操作***/
#include<iostream>
#include<cstdlib>
#include<cstdio>
using namespace std;

#define MAXQSIZE 6
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;

//- - - - - 队列的链式存储结构- - - - -
typedef struct QNode {
   QElemType data;
   struct QNode *next;
} QNode, *QueuePtr;
typedef struct {
   QueuePtr front; //队头指针
   QueuePtr rear; //队尾指针
} LinkQueue;

//算法3.16　链队的初始化
Status InitQueue(LinkQueue &q)  //构造一个空队列Q
{
   q.front = q.rear = new QNode; //生成新结点作为头结点，队头和队尾指针指向此结点
   q.front->next = NULL; //头结点的指针域置空
   return OK;
}

void DestroyQueue(LinkQueue &q)
{
   /* 销毁队列Q(无论空否均可) */
   for(QueuePtr p = q.front, q; p; ) {
      q = p->next;
      delete p;
      p = q;
   }
}

Status QueueEmpty(LinkQueue q)
{
   /****在此下面完成代码************/


   /***********************************/
}

int QueueLength(LinkQueue q)
{
   /****在此下面完成代码************/


   /***********************************/
}

//算法3.17　链队的入队
Status EnQueue(LinkQueue &q, QElemType e)  //插入元素e为Q的新的队尾元素
{
   /****在此下面完成代码************/


   /***********************************/
}

//算法3.18　链队的出队
Status DeQueue(LinkQueue &q, QElemType &e)  //删除Q的队头元素，用e返回其值
{
   /****在此下面完成代码************/


   /***********************************/
}

//算法3.19　取链队的队头元素
QElemType GetHead(LinkQueue q)  //返回Q的队头元素，不修改队头指针
{
   /****在此下面完成代码************/


   /***********************************/
}

void PrintQueue(LinkQueue q)
{
   QueuePtr p;
   for(p = q.front->next; p; p = p->next) {

      cout << p->data;
      if(p->next != NULL)
         cout << ' ';
   }
   cout << endl;
}
int main()
{
   //freopen("linkqueue.out", "w", stdout);
   LinkQueue q;
   QElemType e;
   string op;

   InitQueue(q);
   while(cin >> op) {
      if(op == "Empty") {
         cout << "Queue is " << (QueueEmpty(q) ? "empty" : "not empty") << endl;
      } else if(op == "Length") {
         cout << "The queue length is " << QueueLength(q) << endl;
      } else if(op == "EnQueue") {
         cin >> e;
         if(EnQueue(q, e) == ERROR)
            cout << "EnQueue failure\n";
         else
            PrintQueue(q);
      } else if(op == "DeQueue") {
         if(DeQueue(q, e) == ERROR)
            cout << "DeQueue failure\n";
         else
            PrintQueue(q);
      } else if(op == "Head") {
         if(QueueEmpty(q)) {
            cout << "GetHead failure\n";
         } else
            cout << "The front element is " << GetHead(q) << endl;
      }
   }
   DestroyQueue(q);
   return 0;
}

 

输入

为链队的操作系列，每个操作一行，具体见样例。

输出

如果输入为"EnQueue e", 队已满输出"EnQueue failure"，否则将e入队后再输出从队头到队尾的所有元素。

如果输入为"DeQueue"， 队为空输出"DeQueue failure"，否则删除队头元素后再输出队列中的所有元素。

如果输入为"Empty"，则输出队列是否为空。

如果输入为"Length"，则输出队列的长度。

如果输入为"GetHead"，队列为空则输出"GetHead failure"，否则输出队列的头元素输出从队头到队尾的所有元素。

具体见样例。

样例输入

Empty
Length
Head
DeQueue
EnQueue 1
EnQueue 2
EnQueue 3
Empty
Head
DeQueue
EnQueue 4
EnQueue 5
EnQueue 6
Length
EnQueue 7
DeQueue

样例输出 

Queue is empty
The queue length is 0
GetHead failure
DeQueue failure
1
1 2
1 2 3
Queue is not empty
The front element is 1
2 3
2 3 4
2 3 4 5
2 3 4 5 6
The queue length is 5
2 3 4 5 6 7
3 4 5 6 7

 代码实现

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



#define OK 1
#define MAXQSIZE 6
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;

//- - - - - 队列的链式存储结构- - - - -
typedef struct QNode {
   QElemType data;
   struct QNode *next;
} QNode, *QueuePtr;
typedef struct {
   QueuePtr front; //队头指针
   QueuePtr rear; //队尾指针
} LinkQueue;

//算法3.16　链队的初始化
Status InitQueue(LinkQueue &q)  //构造一个空队列Q
{
   q.front = q.rear = new QNode; //生成新结点作为头结点，队头和队尾指针指向此结点
   q.front->next = NULL; //头结点的指针域置空
   return OK;
}

void DestroyQueue(LinkQueue &q)
{
   /* 销毁队列Q(无论空否均可) */
   for(QueuePtr p = q.front, q; p; ) {
      q = p->next;
      delete p;
      p = q;
   }
}

Status QueueEmpty(LinkQueue q)
{
   /****在此下面完成代码************/
	if(q.front==q.rear) return true;
	else return false; 

   /***********************************/
}

int QueueLength(LinkQueue q)
{
   /****在此下面完成代码************/
   
   int i=0;
   while(q.front!=q.rear){
   	i++;
   	q.front=q.front->next;
   }
	return i;

   /***********************************/
}

//算法3.17　链队的入队
Status EnQueue(LinkQueue &q, QElemType e)  //插入元素e为Q的新的队尾元素
{
   /****在此下面完成代码************/

	QNode *p=new QNode;
	p->data=e;
	p->next=NULL;
	q.rear->next=p;
	q.rear=p;

	return OK;
   /***********************************/
}

//算法3.18　链队的出队
Status DeQueue(LinkQueue &q, QElemType &e)  //删除Q的队头元素，用e返回其值
{
   /****在此下面完成代码************/
	if(q.front==q.rear) return ERROR;

	QNode *p;
	p=q.front->next;
	e=p->data;
	q.front->next=p->next;
	if(q.rear==p)
		q.rear=q.front;
	delete p;
	return OK;
   /***********************************/
}

//算法3.19　取链队的队头元素
QElemType GetHead(LinkQueue q)  //返回Q的队头元素，不修改队头指针
{
   /****在此下面完成代码************/
   QNode *p;
   p=q.front->next;
	 return p->data;

   /***********************************/
}

void PrintQueue(LinkQueue q)
{
   QueuePtr p;
   for(p = q.front->next; p; p = p->next) {

      cout << p->data;
      if(p->next != NULL)
         cout << ' ';
   }
   cout << endl;
}
int main()
{
   //freopen("linkqueue.out", "w", stdout);
   LinkQueue q;
   QElemType e;
   string op;

   InitQueue(q);
   while(cin >> op) {
      if(op == "Empty") {
         cout << "Queue is " << (QueueEmpty(q) ? "empty" : "not empty") << endl;
      } else if(op == "Length") {
         cout << "The queue length is " << QueueLength(q) << endl;
      } else if(op == "EnQueue") {
         cin >> e;
         if(EnQueue(q, e) == ERROR)
            cout << "EnQueue failure\n";
         else
            PrintQueue(q);
      } else if(op == "DeQueue") {
         if(DeQueue(q, e) == ERROR)
            cout << "DeQueue failure\n";
         else
            PrintQueue(q);
      } else if(op == "Head") {
         if(QueueEmpty(q)) {
            cout << "GetHead failure\n";
         } else
            cout << "The front element is " << GetHead(q) << endl;
      }
   }
   DestroyQueue(q);
   return 0;
}