固定大小循环队列-链表，数组实现

题目

力扣链接

链表循环队列

思路

代码

typedef int QDateType;
typedef struct node
{
    
    
	QDateType x;
	struct node* next;
}Queuenode;//定义队列结点


typedef struct {
    
    
   Queuenode*head;//因为在初始化时，需要最终成环，因此记住head
   Queuenode*front;
   Queuenode*tail; 
} MyCircularQueue;
Queuenode* newnode()//创建结点。
{
    
    

	Queuenode* q = (Queuenode*)malloc(sizeof(Queuenode));
	if(q==NULL)
	{
    
    
	perror("q");
	exit(-1);
	}
	q->x = 0;//建立结点先将X初始化0；
	q->next = NULL;
	return q;
}
void QueueDestroy(Queuenode* q)//销毁
{
    
    
	assert(q);
	Queuenode* cur = q;
	while (cur->next!=q)
	{
    
    
		Queuenode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
}

//因为只需要在K+1个结点中插入K个数据就行，K+1结点也可以存放数据，因此当front==tail就为空，即使tail在尾，或者中间
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    
    
assert(obj);

return obj->front==obj->tail;
}
// 因为存在删除数据这个因素，所以当tail->next=front,就行，即使tail在尾，或者中间
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    
    
assert(obj);
return obj->tail->next==obj->front;
}
MyCircularQueue* myCircularQueueCreate(int k) {
    
    
	//这里要建立K+1的结点：
	//1.为了判断数据空还是满方便。
	//2.K+1这个结点也可以正常存储数据
	if (k == 0)
	{
    
    
		return NULL;
	}
	MyCircularQueue* mycircularqueue = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	if (mycircularqueue == NULL)
	{
    
    
		printf("mycircularqueue==NULL\n");
		exit(-1);
	}
	mycircularqueue->head = NULL;
	mycircularqueue->front = NULL;
	mycircularqueue->tail = NULL;
	Queuenode* Sl = NULL;
	while (k > 0)
	{
    
    
			if (Sl == NULL)
			{
    
    
				Queuenode* tmp = newnode();
				Sl = tmp;
				mycircularqueue->head = tmp;
				mycircularqueue->front = tmp;
				mycircularqueue->tail = tmp;
			}
			else
			{
    
    
				Queuenode* tmp = newnode();
				Sl->next = tmp;
				Sl = tmp;
			}
		--k;
	}
	Queuenode* tmp = newnode();
	Sl->next = tmp;
	tmp->next = mycircularqueue->head;
	return mycircularqueue;
}
 
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    
    
assert(obj);
if(!myCircularQueueIsFull(obj))
{
    
    
    obj->tail->x=value;
    obj->tail=obj->tail->next;
    return true;
}
else
{
    
    
    return false;
}
}

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

}

int myCircularQueueFront(MyCircularQueue* obj) {
    
    

assert(obj);

if(myCircularQueueIsEmpty(obj))
{
    
    
    return -1;
}else
{
    
    
return obj->front->x;
}
}

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

    return -1;
}else
{
    
    
    //单链表找结尾只能遍历
Queuenode *cur=obj->front;
while(cur->next!=obj->tail)
{
    
    
    cur=cur->next;
}
return cur->x;
}
}

void myCircularQueueFree(MyCircularQueue* obj) {
    
    
assert(obj);
QueueDestroy(obj->head);
obj->head=NULL;
obj->front=NULL;
obj->tail=NULL;
}

数组循环队列

思路

代码

typedef struct {
    
    
int *arr;
int sz;
int front ;
int tail;
} MyCircularQueue;

//因为tail总是指向下一个数组下标，而front指向的是尚存在数组中的首元素，当front=tail，说明数组中没有元素了，或者说pop空了
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    
    
assert(obj);
return obj->front==obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    
    
assert(obj);
 return  (obj->tail+1)%(obj->sz+1)==obj->front;
}
MyCircularQueue* myCircularQueueCreate(int k) {
    
    

MyCircularQueue* mycircularqueue=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
if(mycircularqueue==NULL)
{
    
    
    printf("mycircularqueue==NULL\n");
    exit(-1);
}
int *ARR=(int *)malloc(sizeof(int)*(k+1));
if(ARR==NULL)
{
    
    
    printf("ARR==NULL\n");
    exit(-1);
}
mycircularqueue->arr=ARR;
mycircularqueue->front=0;
mycircularqueue->tail=0;
mycircularqueue->sz=k;
return mycircularqueue;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    
    
assert(obj);
if(!myCircularQueueIsFull(obj))
{
    
    
obj->arr[obj->tail]=value;
obj->tail=(obj->tail+1)%(obj->sz+1);//下标0很特殊
    return true ;
}else
{
    
    
    return false;
}
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    
    

assert(obj);
if(!myCircularQueueIsEmpty(obj))
{
    
    
obj->front=(obj->front+1)%(obj->sz+1);
return true;
}else
{
    
    
    return false;
}

}

int myCircularQueueFront(MyCircularQueue* obj) {
    
    

assert(obj);

if(!myCircularQueueIsEmpty(obj))
{
    
    
return obj->arr[obj->front];
}else
{
    
    
    return -1;
}
}

int myCircularQueueRear(MyCircularQueue* obj) {
    
    

assert(obj);
if(!myCircularQueueIsEmpty(obj))
{
    
    

   return obj->arr[(obj->tail+obj->sz)%(obj->sz+1)];
}else
{
    
    
    return -1;
}
}

void myCircularQueueFree(MyCircularQueue* obj) {
    
    

assert(obj);
//要先free arr，不然野指针
free(obj->arr);
obj->arr=NULL;
obj->front=0;
obj->tail=0;
obj->sz=0;
free(obj);
}