#include<stdio.h> typedef int QElemType;//定义队列元素为int类型，提前换个名称适合后期对程序修改 typedef int Status; #define MAXSIZE 11 #define OK 1 #define ERROR 0 typedef struct { QElemType data[MAXSIZE]; int front;//定义头指针 int rear;//定义尾指针，若队列不空，指向队列尾元素的下一个位置 }sqQueue; //初始化一个空队列Q Status InitQueue(sqQueue *Q) { Q->front=0; Q->rear=0; return OK; } //循环队列求队列长度 Status QueueLength(sqQueue Q) { return (Q.rear-Q.front+MAXSIZE)%MAXSIZE; } //若队列未满，则插入元素e为Q新的队尾元素 Status EnQueue(sqQueue *Q,QElemType e) { if((Q->rear+1)%MAXSIZE==Q->front)//判断队列是否满 ps：保留一个空余的位置也代表队列满 return ERROR; Q->data[Q->rear]=e;//将元素e赋给队尾------对Q->rear进行思考为啥不是Q->rear+1???与数组 Q->rear=(Q->rear+1)%MAXSIZE;//若在最后一个转到数值头部 return OK; } //若队列不空，则删除Q中队头元素，用e返回其值 Status DeQueue(sqQueue *Q,QElemType *e) { if(Q->front==Q->rear)//队列空的判断 { return ERROR; } *e=Q->data[Q->front]; Q->front=(Q->front+1)%MAXSIZE; return OK; } int main() { int m; int *n; sqQueue Q; InitQueue(&Q); printf("%d\n",QueueLength(Q)); scanf("%d",&m); EnQueue(&Q,m); printf("%d\n",QueueLength(Q)); DeQueue(&Q,n); printf("%d\n",*n); printf("%d\n",QueueLength(Q)); return 0; }

修改后的代码已经可以正常运行。但是在 DeQueue 函数中，需要将元素的值通过指针返回给调用者，因此在 main 函数中定义指针变量 n，然后将其传递给 DeQueue 函数。同时，在 DeQueue 函数中，需要将元素的值通过指针参数返回给调用者，因此需要将第二个参数改为指针类型 QElemType*。

修改后的代码如下：

相关问题

优化这段代码#include<stdio.h> #include<stdlib.h> #define MAXSIZE 6 //最大长度 typedef int QElemType; typedef struct { QElemType *base; //初始化的动态分配存储空间 int front; int rear; //下标 }SqQueue; enum Status{ERROR,OK}; //循环队列初始化 Status InitQueue(SqQueue &Q) { Q.base=new QElemType[MAXSIZE]; if(!Q.base) return ERROR; Q.front=Q.rear=0; //队空 return OK; } //入队 Status EnQueue(SqQueue &Q,QElemType e) { //添加判断语句，如果rear超过max，则直接将其从a[0]重新开始存储，如果rear+1和front重合，则表示数组已满 if ((Q.rear+1)%MAXSIZE==Q.front) { return ERROR; } Q.base[Q.rear]=e; Q.rear=(Q.rear+1)%MAXSIZE; return OK; } //出队 Status DeQueue(SqQueue &Q,QElemType &e) { //如果front==rear，表示队列为空 if(Q.front==Q.rear) return ERROR; e=Q.base[Q.front]; //front不再直接 +1，而是+1后同max进行比较，如果=max，则直接跳转到 a[0] Q.front=(Q.front+1)%MAXSIZE; return OK; } //循环队列长度 int QueueLength (SqQueue Q) { return (Q.rear-Q.front+MAXSIZE)%MAXSIZE; } int main() { QElemType e; SqQueue Q; InitQueue(Q); printf("开始入队\n"); for(int i=0;i<MAXSIZE-1;i++) { scanf("%d",&e); EnQueue(Q,e); } printf("出一个队列元素：\n"); DeQueue(Q,e); printf("%d \n",e); printf("再入一个元素\n"); scanf("%d",&e); EnQueue(Q,e); printf("全部出队列\n"); for(i=0;i<MAXSIZE-1;i++) { DeQueue(Q,e); printf("%d ",e); } printf("此时循环队列长度为 ：%d\n",MAXSIZE-1-QueueLength(Q)); return 0; }

这段代码已经进行了一些优化，但还有一些可以改进的地方：

1. 变量命名

变量名最好能够反映其具体含义，比如将 `Q.base` 改为 `Q.data`，将 `Q.front` 改为 `Q.head`。

2. 枚举类型

枚举类型建议使用驼峰命名法，并且不要全部大写，比如将 `enum Status` 改为 `enum QueueStatus`。

3. 错误处理

在函数调用出错时，建议输出错误提示信息，方便调试和排查错误。比如在 `InitQueue` 函数中，如果分配空间失败，可以输出 "allocate memory failed"。

4. 函数参数

建议将函数中不需要修改的参数加上 const 修饰符，以增强代码的可读性和可维护性。

下面是优化后的代码：

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

#define MAXSIZE 6  //最大长度

typedef int QElemType;

typedef struct {
    QElemType *data;  //初始化的动态分配存储空间
    int head;  //队头
    int tail;  //队尾
} SqQueue;

enum QueueStatus {
    kError,
    kOK
};

//循环队列初始化
QueueStatus InitQueue(SqQueue &Q) {
    Q.data = new QElemType[MAXSIZE];
    if (!Q.data) {
        printf("allocate memory failed\n");
        return kError;
    }
    Q.head = Q.tail = 0;  //队空
    return kOK;
}

//入队
QueueStatus EnQueue(SqQueue &Q, QElemType e) {
    int next = (Q.tail + 1) % MAXSIZE;
    //如果队满
    if (next == Q.head) {
        return kError;
    }
    Q.data[Q.tail] = e;
    Q.tail = next;
    return kOK;
}

//出队
QueueStatus DeQueue(SqQueue &Q, QElemType &e) {
    //如果队空
    if (Q.head == Q.tail) {
        return kError;
    }
    e = Q.data[Q.head];
    Q.head = (Q.head + 1) % MAXSIZE;
    return kOK;
}

//循环队列长度
int QueueLength(const SqQueue &Q) {
    return (Q.tail - Q.head + MAXSIZE) % MAXSIZE;
}

int main() {
    QElemType e;
    SqQueue Q;
    InitQueue(Q);
    printf("开始入队\n");
    for (int i = 0; i < MAXSIZE - 1; i++) {
        scanf("%d", &e);
        EnQueue(Q, e);
    }
    printf("出一个队列元素：\n");
    DeQueue(Q, e);
    printf("%d\n", e);
    printf("再入一个元素\n");
    scanf("%d", &e);
    EnQueue(Q, e);
    printf("全部出队列\n");
    for (int i = 0; i < MAXSIZE - 1; i++) {
        DeQueue(Q, e);
        printf("%d ", e);
    }
    printf("此时循环队列长度为：%d\n", MAXSIZE - 1 - QueueLength(Q));
    return 0;
}

此时代码更加规范、清晰易读，也更加易于维护。

利用队列操作，模拟实现打印作业任务管理。 #define ERROR 1 #define OK 0 #define OVERFLOW 1 typedef int QElemType; typedef int Status; #define MAXQSIZE 100 //最大队列长度 typedef struct { QElemType *base; // 动态分配存储空间 int front; // 头指针，若队列不空，指向队列头元素 int rear; // 尾指针，若队列不空， //指向队列尾元素的下一个位置 }SqQueue;

以下是模拟实现打印作业任务管理的代码：

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

#define ERROR 1
#define OK 0
#define OVERFLOW 1

typedef int QElemType;
typedef int Status;

#define MAXQSIZE 100 //最大队列长度

typedef struct {
    QElemType *base; // 动态分配存储空间
    int front;   // 头指针，若队列不空，指向队列头元素
    int rear;  // 尾指针，若队列不空，
               //指向队列尾元素的下一个位置
} SqQueue;

Status InitQueue(SqQueue *Q) {
    Q->base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
    if (!Q->base) exit(OVERFLOW); //存储分配失败
    Q->front = Q->rear = 0;
    return OK;
}

int 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;
}

Status PrintQueue(SqQueue Q) {
    if (Q.front == Q.rear) {
        printf("队列为空！\n");
        return OK;
    }
    printf("队列中的元素为：");
    int i = Q.front;
    while (i != Q.rear) {
        printf("%d ", Q.base[i]);
        i = (i + 1) % MAXQSIZE;
    }
    printf("\n");
    return OK;
}

int main() {
    SqQueue Q;
    QElemType e;
    InitQueue(&Q);

    printf("请输入打印作业的数量：");
    int n;
    scanf("%d", &n);

    for (int i = 1; i <= n; i++) {
        int job;
        printf("请输入第%d个打印作业需要的打印时间：", i);
        scanf("%d", &job);
        if (EnQueue(&Q, job) == ERROR) {
            printf("队列已满，打印作业%d无法加入队列！\n", i);
        }
    }

    printf("\n打印作业队列中共有%d个打印作业。\n", QueueLength(Q));
    PrintQueue(Q);

    printf("\n开始打印作业...\n");
    while (Q.front != Q.rear) {
        DeQueue(&Q, &e);
        printf("打印作业%d已完成打印，剩余打印作业数量：%d\n", e, QueueLength(Q));
    }
    printf("所有打印作业已完成打印。\n");

    return 0;
}

以上程序实现了一个打印作业任务管理的队列，用户可以输入打印作业的数量和每个打印作业需要的打印时间，程序将打印作业加入队列，并依次完成打印作业。在队列满的情况下，无法将新的打印作业加入队列，并输出相应的提示信息。