05 队列的存储表示和实现

实验目的：
⑴ 熟悉队列的定义和基本操作
⑵ 掌握队列的链式存储结构设计与基本操作的实现
⑶ 掌握队列的顺序存储结构设计与基本操作的实现
实验 任务 与要求：
⑴ 定义队列的链式和顺序存储表示
⑵ 基于所设计的存储结构实现队列的基本操作
⑶ 编写主程序对所实现的队列进行测试
实验 内容 ：
1、采用书上第 61 页定义的队列的链式存储结构，编程实现队列的下列基本操作。
（1）构造空队列 （2）销毁队列 （3）清空队列 （4）判断队列是否为空
（5）求队列长度 （6）取队头元素 （7）插入队尾元素 （8）删除队头元素
（9）输出队列元素
2、采用书上第 64 页定义的队列的顺序存储结构，编程实现循环队列的下列基本操作。
（1）构造空队列 （2）清空队列 （3）判断队列是否为空 （4）求队列长度
（5）取队头元素 （6）插入队尾元素 （7）删除队头元素 （8）输出队列元素

第一题：

#include<iostream>
#include<stdlib.h>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2

typedef int Status;
typedef int ElemType;
typedef struct Qnode
{
    ElemType data;
    struct Qnode* next;//c++中struct可以省略
}Qnode, *QueuePtr;

typedef struct
{
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
}LinkQueue;

Status InitQueue(LinkQueue& q)
{//构造一个空队列
    q.front = q.rear = new Qnode;
    //=(QueuePtr)malloc(sizeof(QNode));
    if (!q.front)
        exit(OVERFLOW);
    q.front->next = NULL;
    return OK;
}

Status DestroyQueue(LinkQueue& Q)
{//销毁队列Q，Q不再存在
    while (Q.front)
    {
        QueuePtr p = Q.front->next;
        free(Q.front);
        Q.front = p;
        //Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;
    }
    return OK;
}

Status ClearQueue(LinkQueue& Q)
{//将Q清为空队列
    QueuePtr p,  q;
    if (!Q.front)
        exit(OVERFLOW);
    Q.rear = Q.front;
    p = Q.front->next;
    Q.front->next = NULL;
    while (p)
    {
        q = p;
        p = p->next;
        delete q;
    }
    return OK;
}

Status QueueEmpty(LinkQueue& Q)
{//Q为空队列，返回TRUE
    if (Q.front->next == NULL)
        return TRUE;
    else
        return FALSE;
}

int QueueLength(LinkQueue& Q)
{//返回Q的元素个数，即队列长度
    QueuePtr p;
    int n = 0;
    p = Q.front;
    while (p != Q.rear)
    {
        p = p->next;
        n++;
    }
    return n;
}

Status GetHead(LinkQueue& Q, ElemType& e)
{//若队列不空，则用e返回Q的队头元素，并返回OK，
    QueuePtr p;
    if (Q.front == Q.rear)
        return ERROR;
    p = Q.front->next;
    e = p->data;
    //e=Q.front->next->data;
    return OK;
}

Status EnQueue(LinkQueue& Q, ElemType e)
{//插入元素e为Q新的队尾元素
    QueuePtr p = new Qnode;
    if (!p)
        exit(OVERFLOW);//存储分配失败
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    return OK;
}

Status DeQueue(LinkQueue& Q, ElemType& e)
{//若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；
    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;//删除的是尾结点，那尾指针也要再指向头节点
    delete p;
    return OK;
}

Status QueueTraverse(LinkQueue Q)
{//从队头到队尾依次输出队列元素的值
    QueuePtr p = Q.front;
    if (p == NULL)
        return ERROR;
    while (p!=Q.rear)
    {
        p = p->next;
        cout << p->data << " ";
        
    }
    cout << endl;
    return OK;
}

int main()
{
    int i, n;
    ElemType h, k, a, f;
    LinkQueue Q;
    cout << "创建一个空队列！" << endl;
    InitQueue(Q);
    cout << "判断队列是否为空！" << endl;
    cout << "QueueEmpty(Q)=" << QueueEmpty(Q) << endl;
    cout << "创建队列的元素个数：" << endl;
    cin >> n;
    cout << "输入" << n << "个插入队列的元素的值：" << endl;
    for (i = 0; i < n; i++)
    {
        cin >> k;
        EnQueue(Q, k);

    }
    cout << "输出队列元素的值：" << endl;
    QueueTraverse(Q);
    cout << "输入插入队列的元素的值：";
    cin >> h;
    EnQueue(Q, h);
    cout << "输入插入一个队列元素后队列的元素值：" << endl;
    QueueTraverse(Q);
    DeQueue(Q, a);
    cout << "输出第1个删除的队头元素的值：" << a << endl;
    DeQueue(Q, a);
    cout << "输出第2个删除的队头元素的值：" << a << endl;
    cout << "输出两次删除队头元素后队列的元素值：";
    QueueTraverse(Q);
    if (GetHead(Q, f))
    {
        cout << "输出队头元素的值：" << f << endl;
    }
    cout << "输出队列元素的个数：" << QueueLength(Q) << endl;
    cout << "将Q清为空队列！" << endl;
    ClearQueue(Q);
    cout << "输出队列元素的个数：" << QueueLength(Q) << endl;
    cout << "判断队列是否为空！" << endl;
    cout << "QueueEmpty(Q)=" << QueueEmpty(Q) << endl;
    return 0;
}

第二题：

#include<iostream>
#include<stdlib.h>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXQSIZE 100

typedef int ElemType;
typedef int Status;
typedef struct
{
    ElemType* base;//初始化的动态分配空间
    int front;//头指针，称作指针，但不是指针变量，只是用来表示数组下标位置，是两个整数
    int rear;//尾指针
}sqQueue;

Status InitQueue(sqQueue& Q)
{//构造空队列
    Q.base = new ElemType[MAXQSIZE];//分配数组空间
    //Q.base=(ElemType*)malloc(MAXQSIZE*sizeof(ElemType));
    if (!Q.base)
        exit(OVERFLOW);
    Q.front = Q.rear = 0;//头指针尾指针置为0，队列为空
    return OK;
}

Status ClearQueue(sqQueue& Q)
{
    if (!Q.base)
        exit(OVERFLOW);
    Q.front = Q.rear = 0;
}

Status QueueEmpty(sqQueue& Q)
{//若队列Q为空队列，返回TRUE，否则返回FALSE
    if (Q.front == Q.rear)
        return OK;
    else
        return ERROR;
}

int QueueLength(sqQueue Q)
{//返回Q的元素个数，即队列的长度
    return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

Status GetHead(sqQueue Q, ElemType& e)
{//若队列不空，用e返回队头元素，返回OK；
    if (Q.front == Q.rear)
        return ERROR;
    e = Q.base[Q.front];//返回队头指针元素的值，队头指针不变
    return OK;
}

Status EnQueue(sqQueue& Q, ElemType e)
{//若队列不空，删除队头元素，用e返回其值，返回OK
    if ((Q.rear + 1) % MAXQSIZE == Q.front)
        return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXQSIZE;
    return OK;
}

Status DeQueue(sqQueue& Q, ElemType& e)
{
    if (Q.front == Q.rear)
        return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXQSIZE;
    return OK;
}

Status QueueTraverse(sqQueue& Q)
{
    int p;
    if (Q.front == Q.rear)
        return ERROR;
    p = Q.front;
    for (p; p < Q.rear; p++)
    {
        cout << Q.base[p] << " ";
    }
    cout << endl;
    return OK;
}

int main()
{
    int i, n;
    ElemType h, k, a, f;
    sqQueue Q;
    cout << "创建一个空队列！" << endl;
    InitQueue(Q);
    cout << "判断队列是否为空！" << endl;
    cout << "QueueEmpty(Q)=" << QueueEmpty(Q) << endl;
    cout << "创建队列的元素个数：" << endl;
    cin >> n;
    cout << "输入" << n << "个插入队列的元素的值：" << endl;
    for (i = 0; i < n; i++)
    {
        cin >> k;
        EnQueue(Q, k);

    }
    cout << "输出队列元素的值：" << endl;
    QueueTraverse(Q);
    cout << "输入插入队列的元素的值：";
    cin >> h;
    EnQueue(Q, h);
    cout << "输入插入一个队列元素后队列的元素值：" << endl;
    QueueTraverse(Q);
    DeQueue(Q, a);
    cout << "输出第1个删除的队头元素的值：" << a << endl;
    DeQueue(Q, a);
    cout << "输出第2个删除的队头元素的值：" << a << endl;
    cout << "输出两次删除队头元素后队列的元素值：";
    QueueTraverse(Q);
    if (GetHead(Q, f))
    {
        cout << "输出队头元素的值：" << f << endl;
    }
    cout << "输出队列元素的个数：" << QueueLength(Q) << endl;
    cout << "将Q清为空队列！" << endl;
    ClearQueue(Q);
    cout << "输出队列元素的个数：" << QueueLength(Q) << endl;
    cout << "判断队列是否为空！" << endl;
    cout << "QueueEmpty(Q)=" << QueueEmpty(Q) << endl;
    return 0;

}