数据结构OJ：设计循环队列-Toy模板网

这篇具有很好参考价值的文章主要介绍了数据结构OJ：设计循环队列。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

题目介绍

数据结构OJ：设计循环队列,数据结构
本题为LeetCode上的经典题目，题目要求我们设计一种循环队列，满足FIFO原则且队尾被连接在队首之后。

思路讲解

题目中介绍循环队列的好处是可以重复利用空间，所以我们很容易想到在初始化时即开辟指定大小的空间，之后便不需要再开辟空间，只需后续销毁即可。

首先我们要选择使用顺序表还是使用链表来实现循环队列，那么我们先对比一下两种方式的优缺点。

使用顺序表的优点主要在开辟空间方便，但缺点就是顺序表的删除元素效率很低，这也是链表相比于顺序表最大的优势，但只要我们稍加思考，就会发现这道题目中顺序表的缺点可以被完美避免，我们可以定义两个整形元素，一个指向队首，一个指向队尾(后文称为头指针和尾指针，虽然我们定义的是整型，但是在顺序表中，可以配合数组的索引，来实现指针的效果)，如果需要出队列，我们只需让头指针+1，就可以不必移动后续数据而打到头删的效果，这种方法的实现得益于我们开头的分析：循环队列可以重复利用空间，我们让头指针+1后，原来头指针所指向的空间我们并不需要销毁，也不需要改变其中的内容，因为后续我们添加元素会将其覆盖。

使用链表的优点在于出队列和入队列很方便(即头删和尾插)，所以大多数人一看到题目首先想到的就是使用链表来实现，但我们分析一下使用链表的缺点，就会发现，使用链表实现这道题会非常复杂。使用链表的缺点就是我们很难判断队列是已满还是为空，因为当头指针和尾指针相同时，可能是队列已满，也可能是队列为空。

通过以上分析，我们选择使用顺序表来实现循环队列。那么具体细节该如何实现呢？

此题的最优解为我们在创建顺序表时，数组的大小创建为(k + 1)的大小，让头指针指向第一个元素，尾指针指向最后一个元素的下一个空间，这样当头指针和尾指针指向相同时，代表头指针追上了尾指针，即队列为空；在结构体中定义一个整形元素，来记录数据的个数，当数据个数==k时，队列已满。文章来源地址https://www.toymoban.com/news/detail-853888.html

参考代码

typedef struct {
    int* list;
    int front;
    int rear;
    int k;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(obj == NULL)
    {
        perror("malloc fail");
        return NULL;
    }

    obj->front = 0;
    obj->rear = 0;
    obj->k = k;
    obj->list = (int*)malloc(sizeof(int) * (k + 1));
    if(obj->list == NULL)
    {
        perror("malloc fail");
        return NULL;
    }

    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);

    if(obj->front == obj->rear)
        return true;
    else
        return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);

    if((obj->rear + 1) % (obj->k + 1) == obj->front)
        return true;
    else
        return false;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);

    if(myCircularQueueIsFull(obj))
        return false;
    
    obj->list[obj->rear] = value;

    obj->rear = (obj->rear + 1) % (obj->k + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return false;

    obj->front = (obj->front + 1) % (obj->k + 1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return -1;

    return obj->list[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return -1;

    return obj->list[(obj->rear - 1 + 1 + obj->k) % (obj->k + 1)];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);

    free(obj->list);
    free(obj);
}