队列---循环队列实现

循环队列详解

概述

循环队列是一种基于数组实现的队列数据结构，其中队列的队首和队尾是通过模运算连接起来形成一个逻辑上的环形结构。这样可以有效地利用数组的空间，避免出现“假溢出”的情况。

结构体定义

循环队列的结构体定义如下：

typedef struct CycleQueue {
    int data[MaxSize]; // 用于存储队列中元素的数组
    int front;         // 队首指针，指向队首元素的前一位
    int rear;          // 队尾指针，指向队尾元素的位置
} CycleQueue;

基本操作

初始化队列

初始化队列时，为结构体分配内存，并设置队首和队尾指针为 0，表示队列为空：

void InitQueue(CycleQueue *&q) {
    q = (CycleQueue *) malloc (sizeof(CycleQueue));
    q->front = q->rear = 0;
}

销毁队列

销毁队列时，释放之前分配的内存空间：

void DestroyQueue(CycleQueue *&q) {
    free(q);
}

判断队列是否为空

通过检查队首和队尾指针是否相等来判断队列是否为空：

bool QueueEmpty(CycleQueue *&q) {
    if (q->rear == q->front) {
        return true;
    } else {
        return false;
    }
}

入队操作

向队列中添加新元素。如果队尾指针的下一位与队首指针相同，则返回 false 表示失败；否则将元素存入队尾，并更新队尾指针：

bool enQueue(CycleQueue *&q, int e) {
    if ((q->rear + 1) % MaxSize == q->front) {
        return false;
    }
    q->data[q->rear] = e;
    q->rear = (q->rear + 1) % MaxSize;
    return true;
}

出队操作

从队列中移除队首元素。如果队首和队尾指针相等，则返回 false 表示失败；否则返回队首元素，并更新队首指针：

bool deQueue(CycleQueue *&q, int e) {
    if (q->front == q->rear) {
        return false;
    }
    e = q->data[q->front];
    q->front = (q->front + 1) % MaxSize;
    return true;
}

打印队列的内容

打印队列中所有元素。如果队列为空，则输出提示信息：

void displayQueue(CycleQueue *q) {
    if (QueueEmpty(q)) {
        printf("循环队列中没有元素\n");
    } else {
        int i = q->front;
        do {
            printf("%d ", q->data[i]);
            i = (i + 1) % MaxSize; // 循环到数组的开头
        } while (i != q->rear); // 终止条件
        printf("\n");
    }
}

示例代码解析

以下是一个简单的程序示例，演示了如何使用上述定义的循环队列进行基本操作：

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10

// 定义队列结构体
typedef struct CycleQueue {
    int data[MaxSize];
    int front;
    int rear;
} CycleQueue;

// 初始化队列
void InitQueue(CycleQueue *&q) {
    q = (CycleQueue *) malloc (sizeof(CycleQueue));
    q->front = q->rear = 0;
}

// 销毁队列
void DestroyQueue(CycleQueue *&q) {
    free(q);
}

// 判断队列是否为空
bool QueueEmpty(CycleQueue *&q) {
    if (q->rear == q->front) {
        return true;
    } else {
        return false;
    }
}

// 入队
bool enQueue(CycleQueue *&q, int e) {
    if ((q->rear + 1) % MaxSize == q->front) {
        return false;
    }
    q->data[q->rear] = e;
    q->rear = (q->rear + 1) % MaxSize;
    return true;
}

// 出队
bool deQueue(CycleQueue *&q, int e) {
    if (q->front == q->rear) {
        return false;
    }
    e = q->data[q->front];
    q->front = (q->front + 1) % MaxSize;
    return true;
}

// 打印输出顺序队列
void displayQueue(CycleQueue *q) {
    if (QueueEmpty(q)) {
        printf("循环队列中没有元素\n");
    } else {
        int i = q->front;
        do {
            printf("%d ", q->data[i]);
            i = (i + 1) % MaxSize; // 循环到数组的开头
        } while (i != q->rear); // 终止条件
        printf("\n");
    }
}

int main() {
    CycleQueue *q;
    InitQueue(q);

    bool enFlag = true;
    while (enFlag) {
        printf("请输入需要入队的数据：");
        int e;
        scanf("%d", &e);
        enFlag = enQueue(q, e);
        displayQueue(q);
        if (enFlag) {
            printf("入队成功\n");
        } else {
            printf("入队失败\n");
        }
        int q;
        printf("是否继续入队？（0/1）:");
        scanf("%d", &q);
        enFlag = q == 1 ? true : false;
    }

    printf("入队结束\n");
    int top;
    printf("是否需要出队？(0/1)\n");
    int deFlag;
    scanf("%d", &deFlag);
    while (deFlag) {
        int e;
        deFlag = deQueue(q, e) ? 1 : 0;
        printf("出队的元素为：%d\n", e);
        displayQueue(q);
        printf("入队成功\n"); // 这里应该是 "出队成功"
        printf("是否继续出队？（0/1）\n");
        if (deFlag) {
            scanf("%d", &deFlag);
        }
    }
    printf("出队结束\n");

    printf("销毁队\n");
    DestroyQueue(q);

    return 0;
}

注意事项

1. 内存管理：确保正确释放分配给队列的内存，避免内存泄漏。
2. 边界条件处理：检查队列满或空的情况，避免越界访问。
3. 输入验证：对于用户输入进行适当的验证，确保程序的健壮性。