队列的基本操作

一、 实验目的
1．掌握队列的思想及其存储实现。
2．掌握队列的常见算法的程序实现。

二、 实验内容及要求
（1） 采用顺序存储实现循环队列的初始化、入队、出队操作。
（2） 采用链式存储实现队列的初始化、入队、出队操作。
（3） 在主函数中设计一个简单的菜单，分别测试上述算法。
（4） *综合训练：
银行排队系统模拟:请用一个队列来模拟银行排队系统，队列中存储序号。请设置一个菜单，包括叫号和排号两个选项。若选择叫号，则输出并删除队首元素；若选择排号，则顺序生成一个序号，加入队列，并输出该序号和前面有多少人等候。

Queue.h

#ifndef DACM_ZSN_QUEUE2_H
#define DACM_ZSN_QUEUE2_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status;

#define MAXQSIZE 100
typedef int QElemType;
/*顺序对列*/
typedef struct {
            QElemType *base;    /*初始化动态分配存储空间*/
    QElemType front;    /* 头指针，指向队头元素*/
    QElemType rear;     /*尾指针，指向队尾元素的下一个位置*/
}SqQueue;
/*链式队列*/
typedef struct QNode{
            QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct LinkQueue{
            QueuePtr front;
    QueuePtr rear;
}LinkQueue;

void menu();

/*顺序队列*/
Status InitQueue(SqQueue &Q);                   /*队列的初始化*/
Status QueueLength(SqQueue Q);               /*返回队列长度*/
Status EnQueue(SqQueue &Q,QElemType e);         /*向循环队列插入元素*/
Status DeQueue(SqQueue &Q,QElemType &e);        /*删除循环队列头部元素*/
void PrintfSqQueue(SqQueue Q);                  /*遍历循环队列*/
/*链式队列*/
Status InitLinkQueue(LinkQueue &LQ);
Status DestroyLinkQueue(LinkQueue&QL);         /*销毁队列*/
Status EnLinkQueue(LinkQueue&LQ,QElemType e);  /*为链式队列插入数据*/
Status DeLinkQueue(LinkQueue&LQ,QElemType &e); /*链式队列出队*/
void PrintfLinkQueue(LinkQueue LQ);             /*遍历链式队列*/
#endif //DACM_ZSN_QUEUE2_H

Queue.cpp

void menu() {
    printf("\t\t\t  队列的基本操作\n\n");
    printf("\t\t\t1.初始化循环队列\n");
    printf("\t\t\t2.遍历循环队列\n");
    printf("\t\t\t3.计算循环队列长度\n");
    printf("\t\t\t4.循环队列入队\n");
    printf("\t\t\t5.循环队列出队\n");
    printf("------------------------------------------------\n");
    printf("\t\t\t6.初始化链式队列\n");
    printf("\t\t\t7.遍历链式队列\n");
    printf("\t\t\t8.链式队列入队\n");
    printf("\t\t\t9.链式队列出队\n");
    printf("\t\t\t10.销毁链式队列\n");
    printf("\t\t\t0.退          出\n\n");
    printf("请输入需要执行的序号:\n");
}
/*顺序队列*/
/*队列的初始化*/
Status InitQueue(SqQueue &Q) {
    //构造一个空队列Q
    Q.base = (QElemType *) malloc(MAXQSIZE * sizeof(QElemType));
    if (!Q.base) exit(OVERFLOW);        //存储分配失败
    Q.front = Q.rear = 0;
    return OK;
}

/*遍历循环队列*/
void PrintfSqQueue(SqQueue Q) {
    int i = Q.front;
    printf("遍历结果为：\n");
    while (i != Q.rear) {
        printf("%d ", Q.base[i]);
        i++;
    }
}

/*返回队列长度*/
QElemType QueueLength(SqQueue Q) {
    return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

/*向循环队列插入元素*/
Status EnQueue(SqQueue &Q, QElemType e) {
    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, QElemType &e) {
    if (Q.front == Q.rear) return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXQSIZE;
    return OK;
}

/*链式队列*/
/*构建一个空队列LQ*/
Status InitLinkQueue(LinkQueue &LQ) {
    LQ.front = LQ.rear = (QueuePtr) malloc(sizeof(QNode));
    if (!LQ.front) exit(OVERFLOW);
    LQ.front->next = NULL;
    return OK;
}

/*遍历链式队列*/
void PrintfLinkQueue(LinkQueue LQ) {
    printf("链式队列遍历如下\n");
    if (LQ.front == LQ.rear)
        printf("空队列\n");
    else {
        QueuePtr p;
        p = LQ.front->next;
        while (p != NULL) {
            printf("%d ", p->data);
            p = p->next;
        }
    }
}

/*销毁队列*/
Status DestroyLinkQueue(LinkQueue &LQ) {
    while (LQ.front) {
        LQ.rear = LQ.front->next;
        free(LQ.front);
        LQ.front = LQ.rear;
    }
    return OK;
}

/*为链式队列插入数据*/
Status EnLinkQueue(LinkQueue &LQ, QElemType e) {
    QueuePtr p;
    p = (QueuePtr) malloc(sizeof(QNode));
    if (!p) exit(OVERFLOW);
    p->data = e;
    p->next = NULL;
    LQ.rear->next = p;
    LQ.rear = p;
    return OK;
}

/*链式队列出队*/
Status DeLinkQueue(LinkQueue &LQ, QElemType &e) {
    if (LQ.front == LQ.rear) return ERROR;
    QueuePtr p;
    p = LQ.front->next;
    e = p->data;
    LQ.front->next = p->next;
    if (LQ.rear == p)
        LQ.rear = LQ.front;
    free(p);
    return OK;
}

int main() {
    SqQueue Q;
    LinkQueue LQ;
    QElemType choice, e;
    while (1) {
        menu();
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                if (InitQueue(Q))
                    printf("循环队列初始化成功\n");
                else
                    printf("循环队列初始化失败");
                break;
            case 2:
                PrintfSqQueue(Q);
                break;
            case 3:
                printf("循环队列的长度为:%d\n", QueueLength(Q));
                break;
            case 4:
                printf("请输入一个数： \n");
                scanf("%d", &e);
                if (EnQueue(Q, e))
                    printf("入队成功\n");
                else
                    printf("入队失败\n");
                printf("新队列为:\n");
                PrintfSqQueue(Q);
                break;
            case 5:
                if (DeQueue(Q, e))
                    printf("删除成功，被删除的元素为: %d\n", e);
                else
                    printf("删除失败\n");
                printf("新队列为:\n");
                PrintfSqQueue(Q);
                break;
            case 6:
                if (InitLinkQueue(LQ))
                    printf("链式队列初始化成功\n");
                else
                    printf("链式队列初始化失败\n");
                break;
            case 7:
                PrintfLinkQueue(LQ);
                break;
            case 8:
                printf("请输入一个数：\n");
                scanf("%d", &e);
                if (EnLinkQueue(LQ, e))
                    printf("添加成功\n");
                else
                    printf("添加失败\n");
                printf("新队列为:\n");
                PrintfLinkQueue(LQ);
                break;
            case 9:
                if (DeLinkQueue(LQ, e))
                    printf("删除成功，删除的元素为: %d\n", e);
                else
                    printf("删除失败\n");
                printf("新队列为:\n");
                PrintfLinkQueue(LQ);
                break;
            case 10:
                printf("销毁成功\n");
                DestroyLinkQueue(LQ);
                break;
            case 0:
                exit(-1);
            default:
                printf("输入错误，请重新输入\n");
        }
    }
}