2024年最新设计循环队列，一线互联网大厂面试真题系统收录

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

// q->tail = newnode;
// }
// }

// int QueueSize(Queue* q)
// {
// assert(q);
// QNode* cur=q->front;
// int count=0;
// while(cur!=NULL)
// {
// count++;
// cur=cur->next;
// }
// return count;
// }

// // 队头出队列
// void QueuePop(Queue* q)
// {
// assert(q);
// assert(q->front && q->tail);

// QNode* next = q->front->next;
// if (next != NULL)
// {
// free(q->front);
// q->front = NULL;
// q->front = next;
// }
// else
// {
// free(q->front);
// q->front = NULL;
// q->tail = NULL;
// }
// }

// // 获取队列头部元素
// QDataType QueueFront(Queue* q)
// {
// assert(q);
// assert(q->front != NULL);
// return q->front->data;
// }

// // 获取队列队尾元素
// QDataType QueueBack(Queue* q)
// {
// assert(q);
// assert(q->tail != NULL);
// return q->tail->data;
// }

// // 检测队列是否为空，如果为空返回非零结果，如果非空返回0
// int QueueEmpty(Queue* q)
// {
// assert(q);
// return q->front ==NULL && q->tail == NULL;
// } 上面是自己的队列 有问题应该
/
#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef int QDataType;

//typedef struct QueueNode
//{
// QDataType data;
// struct QueueNode* next;
//}QNode, *PNode;

typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QNode;

typedef struct Queue
{
QNode* head;
QNode* tail;

//size_t size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);

void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}

void QueueDestory(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}

pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
assert(newnode);

newnode->data = x;
newnode->next = NULL;

if (pq->tail == NULL)
{
assert(pq->head == NULL);
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}

void QueuePop(Queue* pq)
{
assert(pq);
assert(pq->head && pq->tail);

if (pq->head->next == NULL)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}

bool QueueEmpty(Queue* pq)
{
assert(pq);

//return pq->head == NULL && pq->tail == NULL;
return pq->head == NULL;
}

size_t QueueSize(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
size_t size = 0;
while (cur)
{
size++;
cur = cur->next;
}

return size;
}

QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(pq->head);

return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(pq->tail);

return pq->tail->data;
}

// // 销毁队列
// void QueueDestory(Queue* q)
// {
// assert(q);
// assert(q->front == NULL);
// QNode* cur = q->front;
// QNode* next = cur->next;
// while (next != NULL)
// {
// free(cur);
// cur = NULL;
// cur = next;
// next = next->next;
// }
// free(cur);
// cur = NULL;
// }

// void QueueDestory(Queue* pq)
// {
// assert(pq);
// QNode* cur = pq->front;
// while (cur)
// {
// QNode* next = cur->next;
// free(cur);
// cur = next;
// }
// }

///
//以上是栈

//思路:开一个数组，空间为k+1(留空)(因为如果不给k+1个空间，当front==tail会让人疑惑
//到底是为0个数据，还是数据满了，给了之后为0就是相等，满了会隔一个空间)，然后转。

// typedef struct {
// int* a;
// int front;
// int tail;
// int k;
// } MyCircularQueue;

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

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

// bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
// assert(obj);
// if(myCircularQueueIsFull(obj))
// return false;

// obj->a[obj->tail]=value;
// if(obj->tailobj->k)
// {
// obj->tail=0;
// }
// else
// {
// obj->tail++;
// }
// return true;
// // if(obj->frontobj->tail)
// // {
// // obj->a[obj->tail]=value;
// // obj->tail++;
// // }
// // else
// // {
// // obj->a[obj->tail]=value;
// // if(obj->tail==obj->k)
// // {
// // obj->tail=0;
// // }
// // else
// // {
// // obj->tail++;
// // }
// // }
// // return true;
// }

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

// // if((obj->front+1obj->tail)||(obj->front-obj->tailobj->k))
// // {
// // return false;
// // }

// if(obj->front==obj->k)
// {
// obj->front=0;
// }
// else
// {
// obj->front++;
// }
// return true;
// // if(obj->frontk)
// // {
// // obj->front++;
// // }
// // else
// // {
// // obj->front=0;
// // }
// // return true;
// }

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

// return obj->a[obj->front];
// // if(obj->front==obj->tail)
// // {
// // return -1;
// // }
// // else
// // {
// // return obj->a[obj->front];
// // }
// }

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

// if(obj->tail0)
// {
// return obj->a[obj->k];
// }
// else
// {
// return obj->a[obj->tail-1];
// }
// // if(obj->frontobj->tail)
// // {
// // return -1;
// // }
// // else
// // {
// // return obj->a[obj->tail];
// // }
// }

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

// return obj->front==obj->tail;
// }

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

// //if((obj->tail+1obj->front)||(obj->front-obj->tail0))
// if(obj->tailobj->k && obj->front0)
// {
// return true;
// }
// else
// {
// return obj->tail+1==obj->front;
// //return false;
// }
// }

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

// free(obj->a);

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

Free(MyCircularQueue* obj) {

// assert(obj);

// free(obj->a);

[外链图片转存中…(img-fv02aNTt-1715674078149)]
[外链图片转存中…(img-eSGb6Odb-1715674078149)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！