leetcode 622.设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

这里使用数组来实现循环队列。

//CircularQueue.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int CQDataType;

typedef struct
{
	CQDataType* pc;
	int front;
	int tail;
	int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k);

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value);

bool myCircularQueueDeQueue(MyCircularQueue* obj);

int myCircularQueueFront(MyCircularQueue* obj);

int myCircularQueueRear(MyCircularQueue* obj);

bool myCircularQueueIsEmpty(MyCircularQueue* obj);

bool myCircularQueueIsFull(MyCircularQueue* obj);

void myCircularQueueFree(MyCircularQueue* obj);

//CircularQueue.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "CircularQueue.h"

MyCircularQueue* myCircularQueueCreate(int k) 
{
	MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	if (q == NULL)
	{
		exit(-1);
	}
	CQDataType* tmp = (CQDataType*)malloc((k + 1) * sizeof(CQDataType));
	if (tmp == NULL)
	{
		exit(-1);
	}

	q->k = k;
	q->pc = tmp;
	q->front = q->tail = 0;

	return q;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
	assert(obj != NULL);
	if (myCircularQueueIsFull(obj))
	{
		return false;
	}

	//入队
	(obj->pc)[obj->tail] = value;
	
	//判断是否满了
	//if (!myCircularQueueIsFull(obj))
	//{
	//	//没满
	//	if (obj->tail == obj->k)
	//	{
	//		obj->tail = 0;
	//	}
	//	else
	//	{
	//		obj->tail++;
	//	}
	//}	
	
	++obj->tail;
	obj->tail %= (obj->k + 1);
	return true;
}

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

	if (myCircularQueueIsEmpty(obj))
	{
		return false;
	}

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

int myCircularQueueFront(MyCircularQueue* obj) 
{
	assert(obj);

	//if (myCircularQueueIsEmpty(obj))
	//{
	//	return -1;
	//}

	//return obj->pc[obj->front];

	return myCircularQueueIsEmpty(obj)?-1: obj->pc[obj->front];
}

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

	if (myCircularQueueIsEmpty(obj))
	{
		return -1;
	}
	else
	{
		if (obj->tail == 0)
		{
			return obj->pc[obj->k];
		}
		else
		{
			return obj->pc[obj->tail - 1];
		}		
	}
}

//int myCircularQueueRear(MyCircularQueue* obj)
//{
//	assert(obj);
//
//	if (myCircularQueueIsEmpty(obj))
//	{
//		return -1;
//	}
//	int i = (obj->tail + obj->k) % (obj->k + 1);
//	return obj->pc[i];
//}


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

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

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

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