线性结构——队列

前言：基本所有的代码都是在Linux环境下运行，若遇到文件类型问题，在Linux系统下可以使用dos2unix，unix2dos命令改变，在Windows系统下可以使用UltraEdit文本编辑器改变。

两个队列实现栈

一般的实现方法有两种，其一，只维护一个队列，另一个队列作为临时存放队列；其二，维护两个队列，需要用判断来分辨队列是否为空，避免了多余的进、出队列操作。

首先来说说第一种方法：



再来说说第二种方法，其实就是同时维护QA,QB，用 if 来判断QA,QB哪个为空，如果一个为空，就将这一个作为临时存放队列，这样就省去了临时队列中的元素再回到原队列的步骤，具体图就不放了。

第一种方法的代码：

/*
* 两个队列实现栈(只维护队列Q)
*/
Status Pop(LinkQueue *Q, QElemType *e)
{
QElemType *Te;
LinkQueue Tq;
InitQueue(&Tq);
QueuePtr p = Q->front->next;

if(Q->front == Q->rear)
{
return ERROR;
}
// 输出队列Q直到最后一个元素
while(!IsEmpty(*Q))
{
if(p->next != NULL)
{
EnQueue(&Tq, p->data);
}
*e = p->data;
DeQueue(Q, *e);
p = p->next;
}
// 将临时队列Tq的元素放入Q
QueuePtr Tp = Tq.front->next;
while(!IsEmpty(Tq))
{
EnQueue(Q, Tp->data);
DeQueue(&Tq, *e);
Tp = Tp->next;
}

DestroyQueue(&Tq);
return OK;
}队列基本操作完整代码如下：

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#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;

/*
* 初始化队列
*/
Status InitQueue(LinkQueue *Q)
{
Q->front = Q->rear = (QueuePtr) malloc(sizeof(QNode));
if (!Q->front)
{
exit(OVERFLOW);
}
Q->front->next = NULL;
return OK;
}

/*
* 销毁队列
*/
Status DestroyQueue(LinkQueue *Q)
{
while (Q->front)
{
Q->rear = Q->front->next;
free(Q->front);
Q->front = Q->rear;
}
return OK;
}

/*
* 清空队列
*/
Status ClearQueue(LinkQueue *Q)
{
DestroyQueue(Q);
InitQueue(Q);
return OK;
}

/*
* 判断队列是否为空
*/
Status IsEmpty(LinkQueue Q)
{
if (Q.front->next == NULL)
{
return TRUE;
}
else
{
return FALSE;
}
}

/*
* 获取队列的长度
*/
int GetLength(LinkQueue Q)
{
int i = 0;
QueuePtr p = Q.front;
while (Q.rear != p)
{
i++;
p = p->next;
}
return i;
}

/*
* 获取队头元素
*/
Status GetHead(LinkQueue Q, QElemType *e)
{
QueuePtr p;
if (Q.front == Q.rear)
{
return ERROR;
}
p = Q.front->next;
*e = p->data;
return OK;
}

/*
* 入队
*/
Status EnQueue(LinkQueue *Q, QElemType e)
{
QueuePtr p = (QueuePtr) malloc(sizeof(QNode));
if (!p)
{
exit(OVERFLOW);
}
p->data = e;
p->next = NULL;
Q->rear->next = p;
Q->rear = p;
return OK;
}

/*
* 出队
*/
Status DeQueue(LinkQueue *Q, QElemType e)
{
QueuePtr p;
if (Q->front == Q->rear)
{
return ERROR;
}
p = Q->front->next;
e = p->data;
Q->front->next = p->next;
if (Q->rear == p)
{
Q->rear = Q->front;
}
free(p);
return OK;
}

/*
* 访问元素
*/
void visit(QElemType e)
{
printf("%d ", e);
}

/*
* 遍历队列
*/
Status TraverseQueue(LinkQueue Q, void (*visit)(QElemType))
{
QueuePtr p = Q.front->next;
while (p)
{
visit(p->data);
p = p->next;
}
return OK;
}

/*
* 两个队列实现栈(只维护队列Q)
*/
Status Pop(LinkQueue *Q, QElemType *e)
{
QElemType *Te;
LinkQueue Tq;
InitQueue(&Tq);
QueuePtr p = Q->front->next;

if(Q->front == Q->rear)
{
return ERROR;
}
//  输出队列Q直到最后一个元素
while(!IsEmpty(*Q))
{
if(p->next != NULL)
{
EnQueue(&Tq, p->data);
}
*e = p->data;
DeQueue(Q, *e);
p = p->next;
}
//  将临时队列Tq的元素放入Q
QueuePtr Tp = Tq.front->next;
while(!IsEmpty(Tq))
{
EnQueue(Q, Tp->data);
DeQueue(&Tq, *e);
Tp = Tp->next;
}

DestroyQueue(&Tq);
return OK;
}

int main()
{
LinkQueue Q;
if (InitQueue(&Q))
{
QElemType e;
int i;

printf("init_success\n");

if (IsEmpty(Q))
{
printf("queue is empty\n");
}

for (i = 0; i < 10; i++)
{
EnQueue(&Q, i);
}

GetHead(Q, &e);
printf("The first element is %d\n", e);

printf("length is %d\n", GetLength(Q));

DeQueue(&Q, e);
printf("delete element is %d\n", e);

Pop(&Q, &e);
printf("Pop element is %d\n", e);

TraverseQueue(Q, *visit);

if (DestroyQueue(&Q))
{
printf("\ndestroy_success\n");
}
}
}