循环队列详解!!c 语言版本(两种方法)双向链表和数组法!!

目录

1.什么是循环队列

2.循环队列的实现(两种方法)

第一种方法 数组法

1.源代码

2.源代码详解!!

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

2.队列判空

3.队列判满(重点)

4.队列的元素插入

5.队列的元素删除

6.队列的头元素

7.队列的尾元素(重点)

8.队列空间的释放

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

1.源代码

2.源代码详解!!

 1.创造哨兵位 和 struct 变量

2. 队列判空和队列判满

3.元素插入

4.元素删除

5.头元素

6.尾元素

7.空间的释放

三关于这两种方法的差距 

3.循环队列有什么用


1.什么是循环队列

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

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

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

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

循环队列详解!!c 语言版本(两种方法)双向链表和数组法!!_第1张图片

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

其中和队列一样有两个指针指向头和尾。添加实在尾针处加,而删除就是将队首的元素删除。为什么循环呢?就是在你的尾指针走到最后一格的时候(就是总共有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)];
}

 循环队列详解!!c 语言版本(两种方法)双向链表和数组法!!_第2张图片

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

因为由前面的插入操作我们可以知道,在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.循环队列有什么用

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

你可能感兴趣的:(数据结构,c语言,c语言,开发语言,c++,数据结构,链表)