设计循环队列

队列

        队列是一种基本的数据结构，与后入先出的栈相反，队列具有先入先出的规则。其基本操作有入队，出队。

        通过以下代码可以创建一个最简单的队列，存储int类型数据。

#include <stdio.h>
#include <stdlib.h>
#define MAX 50

//队列类型的定义 
typedef struct
{
    ElemType data[MAX];
    int front, rear;//front为队首指针  rear为队尾指针
}SqQueue;

typedef int ElemType;
typedef SqQueue CSqQueue;

//初始化运算
/*初始化运算得到一个空队列*/
int InitQueue(CSqQueue* Q)
{
    (*Q).front = 0;
    (*Q).rear = 0;
    return 0;
}

//判空运算，队列Q为空返回1，否则返回0
int QueueEmpty(CSqQueue Q)
{
    if (Q.front == Q.rear)
        return 1;
    return 0;
}

//判满运算 
int QueueFull(CSqQueue Q)
{
    if ((Q.rear + 1) % MAX == Q.front)
        return 1;
    return 0;
}

//创建一个队列，创建成功返回1，创建失败返回0
int CreatQueue(CSqQueue* Q)
{
    int i, n;
    ElemType temp_e;
    printf("请输入你想要创建的队列的长度：\n");
    scanf("%d", &n);
    if (n > MAX)
        return -1;
    for (i = 1; i <= n; i++) {
        printf("请输入第%d个元素:\n", i);
        scanf("%d", &temp_e);
        EnQueue(Q, temp_e);
    }
    return 0;
}

//返回队列长度
int QueueLength(CSqQueue Q)
{
    return (Q.rear - Q.front + MAX) % MAX;
}

//返回队首元素的值
int GetHead(CSqQueue Q, ElemType* e)
{
    if (QueueEmpty(Q))
    {
        return-1;
    }
    *e = Q.data[Q.front];
    return 0;
}

//入队的实现-队尾插入新元素
int EnQueue(CSqQueue* Q, ElemType e)
{
    if (QueueEmpty(*Q))
    {
        return-1;
    }
    (*Q).data[(*Q).rear] = e;
    (*Q).rear = ((*Q).rear + 1) % MAX;
    return 0;
}

//出队的实现-删除队首，并用变量e返回被删除元素
int DeQueue(CSqQueue* Q, ElemType* e)
{
    if (QueueEmpty(*Q))
    {
        return-1;
    }
    e = (*Q).data[(*Q).front];
    (*Q).front = ((*Q).front + 1) % MAX;
    return 0;
}

        上面的实现很简单，但在某些情况下效率很低。 随着起始指针的移动，浪费了越来越多的空间。 当我们有空间限制时，这将是难以接受的。

        更有效的方法是使用循环队列。 具体来说，我们可以使用固定大小的数组和两个指针来指示起始位置和结束位置。 目的是重用我们之前提到的被浪费的存储。

循环队列

        循环队列，需要两个变量来分别表示，队列的头(Front)(队中第一个元素)，队列的尾(Back)(队中最后一个元素) 但是，如果队列中所有空间都存放数据，没有一个标志性东西，就无法判断队列是否空或是否满 所以一般会保证队列中有一个空的空间，一般是最后一个元素的后一位空间。这样可以保证不会出现 队列所有空间存放数据导致无法判断循环队列是否已满 ，无法判断就无法判断是否进行下个入队操作 所以，循环队列如果需要存储 k 个数据，就需要开辟 k+1 个空间 队尾(Back)的位置，一般处于循环队列最后一个数据的下一位(此位为空)(ps:上图为了方便理解将 Back 置于了最后一个元素上) 然后可以画图分析， 当 Front 位置 === Back 位置时候，循环队列为空 当 Front 位置 在 Back 位置的后一位，循环队列为满 但是，要注意数组模式的循环队列，数组的最后一个空间和数组的第一个空间物理空间上不是连续的，但是要保证循环效果，Front 和 Back 两个变量在数组的最后一个空间的时候，要单独考虑。

        通过以下代码实现循环队列。

typedef struct
{
    int* data;          // 存放数据的数组
    int front;          // 队列头位置变量
    int back;           // 队列尾位置变量
    int k;              // 存放数据空间的大小，真正开辟空间需要 +1
} MyCircularQueue;

bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    obj->data = (int*)malloc((k + 1) * sizeof(int));
    obj->front = obj->back = 0;
    obj->k = k;

    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{   // 入队操作，如果成功返回 true，不成功返回 false

    if(myCircularQueueIsFull(obj))          // 如果循环队列为满，直接返回 false
        return false;

    // 循环队列不满
    obj->data[obj->back] = value;           // 在 数组 back 位置赋值
    if(obj->back == obj->k)
    {//判断 back 位置 是否在数组最后一个空间
        obj->back = 0;      //若 back 在数组最后一个空间，back位置赋值之后，back回到0位置
    }
    else
    {
        obj->back++;    //若 back 不在数组最后一个空间，back 位置++就行
    }

    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj)
{

    if(myCircularQueueIsEmpty(obj))
        return false;

    // 思路同上
    if(obj->front == obj->k)
    {
        obj->front = 0;
    }
    else
    {
        obj->front++;
    }

    return true;
}

int myCircularQueueFront(MyCircularQueue* obj)
{

    if(myCircularQueueIsEmpty(obj))
        return -1;
    
    return obj->data[obj->front];       //队列不为空直接返回 front位置数据
}

int myCircularQueueRear(MyCircularQueue* obj)
{

    if(myCircularQueueIsEmpty(obj))
        return -1;

    // 队列不为空，如果 back 位置在数组首空间(0)，则队列尾元素就是 k 位置的值
    if(obj->back == 0)
    {
        return obj->data[obj->k];
    }
    else
    {// 如果 back 不在数组的首空间，则 队尾元素就是 back - 1 位置的值
        return obj->data[obj->back - 1];
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{

    return obj->front == obj->back;
}

bool myCircularQueueIsFull(MyCircularQueue* obj)
{

    if(obj->back == obj->k && obj->front == 0)
    {
        return true;
    }
    else
    {
        return obj->back+1 == obj->front;
    }
}

void myCircularQueueFree(MyCircularQueue* obj)
{
    free(obj->data);
    free(obj);
}