循环队列详解！！c 语言版本（两种方法）双向链表和数组法！！

最新推荐文章于 2024-01-15 11:27:49 发布

自律的阿龙

最新推荐文章于 2024-01-15 11:27:49 发布

阅读量226

点赞数

分类专栏：数据结构 c语言文章标签： c语言开发语言 c++ 数据结构链表

本文链接：https://blog.csdn.net/a1275174052/article/details/134539643

版权

c语言同时被 2 个专栏收录

49 篇文章 1 订阅

订阅专栏

数据结构

8 篇文章 0 订阅

订阅专栏

1.什么是循环队列

首先关于循环队列，你得先知道什么是队列，详情可以去看看我的另一篇博客

数据结构栈与队列详解！！-CSDN博客

这里简单的说一下，队列就是字面意思，你在银行排队，你不是什么VIP只是普通人，那你先排队那你就先得服务，队列就是你先插入的数字（入队），就得先放出（出队）。大致就是这个意思。

而循环队列呢？他的原理也是队列，但和队列不同的地方在于，他的空间是固定的。在一个空间里进行重复的入队出队。

这是一张循环队列的大致图。

其中和队列一样有两个指针指向头和尾。添加实在尾针处加，而删除就是将队首的元素删除。为什么循环呢？就是在你的尾指针走到最后一格的时候（就是总共有5个空间，你的尾指针已经走到5并且已经插入数据）你的队列就满了，这时候循环队列已经不能插入数据，只能删除数据。

删除数据就是把你的头指针的元素删除，如果删除走到尾指针，头和尾在一个位置了。

所以综上可以抽象出，当你的头和尾指针走到一起的时候，这时候队列是空。

但你的尾走到底头元素的上一个，那就说明你的队列已充满。

当队尾追到了队头那就是满，当队头追到了队尾那就是空

2.循环队列的实现（两种方法）

第一种方法数组法

数组法采用的是多开辟一个空间，用来做假溢出，判断队列是否充满，当然还有一种定size法，大家可以讨论一下！！

1.源代码

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


MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	obj->a = (int*)malloc(sizeof(int) * (k + 1));
	obj->k = k;
	obj->front = 0;
	obj->rear = 0;
	return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	return obj->front == obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
	return (obj->rear + 1) % (obj->k + 1) == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if (myCircularQueueIsFull(obj))
	{
		return false;
	}
	obj->rear %= obj->k + 1;
	obj->a[obj->rear] = value;

	obj->rear++;
	return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
	{
		return false;
	}
	obj->front %= obj->k + 1;
	obj->front++;
	return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
	{
		return -1;
	}
	return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
	{
		return -1;
	}
	return obj->a[obj->rear - 1];
}



void myCircularQueueFree(MyCircularQueue* obj) {
	free(obj->a);
	obj->a = NULL;
	free(obj);
	obj = NULL;
}

2.源代码详解！！

1.创造队列空间和struct变量

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


MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	obj->a = (int*)malloc(sizeof(int) * (k + 1));
	obj->k = k;
	obj->front = 0;
	obj->rear = 0;
	return obj;
}

关于匿名typedef struc 就是定义了一个类型名就叫做MyCircularQueue。

里面的元素第一个用来开辟空间，第二个定义头指针，第三个定义尾指针，第4个就是空间的大小。（这里的指针并不是真的指针，而是对于一个数组来说的下标）

关于创造队列的空间，首先既然他是一个结构体变量，那得先给他开辟一个空间用来给里面的元素地址存储

第二因为你是要在一个数组里进行循环队列，那你就得开辟一块数组的空间。（k+1是因为这里采用的是多开辟一格进行判满）。

第三给结构体里的变量赋初始值。

2.队列判空

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	return obj->front == obj->rear;
}

关于队列的判空，就是两个队头和队尾指针如果重叠时，两者应该是满了或者空了的关系，所以两者的判断表达式不能相同，所以下面的判满得想到另一个表达式才能保证队列不报错（当队尾追到了队头那就是满，当队头追到了队尾那就是空）

3.队列判满（重点）

bool myCircularQueueIsFull(MyCircularQueue* obj) {
	return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

这里关于队列的判满，采用的是这一串表达式的原因是，假设这时你开辟的有元素的空间是3，那现在的K就是3，但由于采用的是多开辟一格来判满的方法，那就是代表了开辟了4个空间。

4个空间对应的下标为0 1 2 3.那为什么要改两个指针rear和k加一呢？假设这时你的rear和front 都还在下标为 0 的位置，如果你不给 rear 加一，那你得出的结果就是 0 % 4 == 0.

这样导致的后果就是和上面判空的条件是一样的 0 == 0.会导致插入操作错误，会一直判满从而不能进行插入。

而如果你给 rear 和 k 都加一就变成了 1 % 4 == 1.而这时 front 是 = 0的

就不会出现误判的情况。只有当你的 rear 走到你多开辟的那一块空间后才会出现判满的情况。（这只是当 front 没变的情况下的讨论，关于 front改变后的讨论，你可以构思一下大致相同。）

4.队列的元素插入

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if (myCircularQueueIsFull(obj))
	{
		return false;
	}
	obj->rear %= obj->k + 1;
	obj->a[obj->rear] = value;

	obj->rear++;
	return true;
}

队列的插入就是在rear的下标初进行插入。首先你要进行判满，是因为循环队列如果满了以后就不会在追加新的元素，就很像游戏里的背包，满了以后就不能获得物品。为什么要让rear % k+1呢？因为当你的元素走到最后一格的下一格，这时候是越界访问的。因为是循环队列，所以可以把他重新变到下标为 0 的位置。

我们的rear 的位置，每次都会加1 所以每次是在rear 的位置插入数据。

5.队列的元素删除

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
	{
		return false;
	}
	
	obj->front++;
    obj->front %= obj->k + 1;
	return true;
}

元素删除，首先如果你的队列为空那就删除不了了，返回false。

如果不为空，那front++ 即可，并且和 rear 一样要 % k+1，是为了使队列变成循环。如果不这样就会越界访问并且与题意不符（循环）。

要先++ 的原因是，如果你后++ 就会导致，如果此时你的front已经处于最后一个位置，

后++就会导致取头元素时越界。如果先++ ，然后在%k+1 这样在出了最后一格以后可以及时，变回0 下标，不会越界。

6.队列的头元素

int myCircularQueueFront(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
	{
		return -1;
	}
	return obj->a[obj->front];
}

返回头元素相较简单，只要返回此时front 位置的元素即可。

7.队列的尾元素（重点）

int myCircularQueueRear(MyCircularQueue* obj) {
	if (myCircularQueueIsEmpty(obj))
	{
		return -1;
	}
	//if (obj->rear == 0)
	//{
	//	return obj->a[obj->k];
	//}
	//else
	//{
	//	return obj->a[obj->rear - 1];
	//}
	return obj->a[((obj->rear - 1) + (obj->k + 1)) % (obj->k + 1)];
}

和头元素的不同点在于，队尾元素不能直接取队尾的下标。

因为由前面的插入操作我们可以知道，在rear位置插入数据后，rear是要进行++的，此时在rear下标里是没有元素的，队尾实际上是在rear 的前一个下标的位置。

但如果你只用 obj->a[obj->rear - 1] 来访问的话（如果你的rear是先%k +1，再++是可以的），但如果是先++，再%就不可以了，你可以思考一下当rear == 0，的时候，那你访问的就是obj->[-1] 那就是未知访问，错误。有两种方法。

第一种，判断当rear == 0的时候，你可以直接选择返回最后一格 obj->k 的元素，

rear ！= 0时就返回 obj->rear - 1的下标的元素。

第二种，直接判断不用 if else，obj->a[((obj->rear - 1) + (obj->k + 1)) % (obj->k + 1)]。

这串表达式的意思就是，因为我们是要返回 rear - 1下标位置的元素，所以我们 rear - 1；

而加上 k +1的原因是在 rear -1 的位置下，你加+ 上这个循环队列的大小，那你还是在原地的，这里是为了防止特殊情况 rear = -1 时，rear = -1 原本是想访问队列最后一个空间的元素，但等于 - 1访问不到，所以 rear = -1 加上一个 k+1,其实就是等于 k ，k % k +1 = k。所以访问最后一个位置的元素。

8.队列空间的释放

void myCircularQueueFree(MyCircularQueue* obj) {
	free(obj->a);
	obj->a = NULL;
	free(obj);
	obj = NULL;
}

将开辟的空间释放即可，但要先释放obj->a 处的空间。

第二种方法双向循环链表法

1.源代码

typedef struct MyCircularQueue {
    struct MyCircularQueue* prev;
    struct MyCircularQueue* next;
    int val;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* phead = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    phead->next = phead;
    phead->prev = phead;
    phead->val = -1;
    phead->k = k;
    return phead;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if (obj->next == obj)
    {
        return true;
    }
    return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    MyCircularQueue* cur = obj->next;
    int size = 1;
    while (cur != obj)
    {
        cur = cur->next;
        size++;
    }
    return size == obj->k;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    MyCircularQueue* newnode = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (newnode == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    newnode->val = value;
    MyCircularQueue* prev = obj->prev;
    newnode->prev = prev;
    newnode->next = obj;
    prev->next = newnode;
    obj->prev = newnode;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    MyCircularQueue* Next = obj->next;
    obj->next = Next->next;
    Next->next->prev = obj;
    free(Next);
    Next = NULL;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->next->val;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->prev->val;
}



void myCircularQueueFree(MyCircularQueue* obj) {
    MyCircularQueue* cur = obj->next;
    while (cur != obj)
    {
        MyCircularQueue* del = cur;
        cur = cur->next;
        free(del);
        del = NULL;
    }
    free(obj);
    obj = NULL;
}

2.源代码详解！！

1.创造哨兵位和 struct 变量

typedef struct MyCircularQueue {
    struct MyCircularQueue* prev;
    struct MyCircularQueue* next;
    int val;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* phead = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    phead->next = phead;
    phead->prev = phead;
    phead->val = -1;
    phead->k = k;
    return phead;
}

我们定义一个双链表的struct 结构。

然后再定义一个头结点，并且将变量赋值。

2. 队列判空和队列判满

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if (obj->next == obj)
    {
        return true;
    }
    return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    MyCircularQueue* cur = obj->next;
    int size = 0;
    while (cur != obj)
    {
        cur = cur->next;
        size++;
    }
    return size == obj->k;
}

相较于数组的循环队列，双链表的判空判满就比较简单。空就是只有一个哨兵位就是空。

满就是用一个size ++ 遍历链表，后如果size == obj->k 就是满。size 必须从 0 开始。

因为不从0 开始，总体队列会少一个空间。

3.元素插入

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    MyCircularQueue* newnode = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (newnode == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    newnode->val = value;
    MyCircularQueue* prev = obj->prev;
    newnode->prev = prev;
    newnode->next = obj;
    prev->next = newnode;
    obj->prev = newnode;
    return true;
}

元素的插入就是双链表的尾插。

4.元素删除

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    MyCircularQueue* Next = obj->next;
    obj->next = Next->next;
    Next->next->prev = obj;
    free(Next);
    Next = NULL;
    return true;
}

元素删除就是双链表的头删。

5.头元素

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->next->val;
}

返回头元素

6.尾元素

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->prev->val;
}

返回尾元素

7.空间的释放

void myCircularQueueFree(MyCircularQueue* obj) {
    MyCircularQueue* cur = obj->next;
    while (cur != obj)
    {
        MyCircularQueue* del = cur;
        cur = cur->next;
        free(del);
        del = NULL;
    }
    free(obj);
    obj = NULL;
}

双链表的销毁。

三关于这两种方法的差距

首先在数组方法中，我们并没有采用循环来执行，这样的时间复杂度是0（1），而双向链表中有多处我们采用了while 循环所以时间复杂度是 o（n）。

数组写法中坑很多需要很多思考，但是总体代码量是偏少的。

而链表虽然简单明了，但代码量是稍微多一点。需要细心检查。

3.循环队列有什么用

应用场景广泛：由于其高效的插入和删除操作、空间利用率高以及能够动态调整队列大小的特性，循环队列在许多领域都有广泛的应用，如操作系统中的任务调度、通信协议中的数据包处理、线程池中的线程管理等。所以循环队列是比较重要的

自律的阿龙

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
循环队列详解！！c 语言版本（两种方法）双向链表和数组法！！

首先关于循环队列，你得先知道什么是队列，详情可以去看看我的另一篇博客数据结构栈与队列详解！！-CSDN博客这里简单的说一下，队列就是字面意思，你在银行排队，你不是什么VIP只是普通人，那你先排队那你就先得服务，队列就是你先插入的数字（入队），就得先放出（出队）。大致就是这个意思。而循环队列呢？他的原理也是队列，但和队列不同的地方在于，他的空间是固定的。在一个空间里进行重复的入队出队。这是一张循环队列的大致图。其中和队列一样有两个指针指向头和尾。添加实在尾针处加，而删除就是将队首的元素删除。
复制链接

扫一扫