Leetcode 循环队列设计

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

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/design-circular-queue

思路：每一个结构体需要指向前一个和后一个结构体。
当尾指针为空的时候链表为空
当头指针的前一个就是尾指针的时候链表已满

MyCircularQueue* myCircularQueueCreate(int k) {
   int i = 0;
	
	if (k == 0) {   //对0长度特殊处理
		return head ;
	}
	else {
		struct MyCircularQueue *pi1= (struct MyCircularQueue*) malloc(sizeof(MyCircularQueue));  //开始进行构造头结点
		pi1->value = 10;
		
		head= pi1;
		tail = pi1;
		struct MyCircularQueue *pi2;
		pi2 = pi1;
		for (i=1+1; i <= k; i++) { //将头结点和后续k-1课结点连接起来
			
			pi2 = (struct MyCircularQueue*) malloc(sizeof(MyCircularQueue));
			pi2->value = 10*(i);
			pi1->back = pi2;
			pi2->front = pi1;
			pi1=pi2;
		}
		tail = pi2;//进行初始化处理将循环链表首尾连接，尾指针为空时队列为空，首尾指在一起的时候有一个
		tail->back = head;
		head->front = tail;
		tail=NULL;
		
		return head;
	}
}

/** Insert an element into the circular queue. Return true if the operation is successful. */
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
  if (head->front == tail) {//判断头指针前面是不是紧挨着尾指针，如果是则队列已满
		return 0;
	}
	else {
		if (NULL == tail) {//如果队列为空，在进行第一次赋值以后要对尾指针进行更改
			head->value = value;
			tail = head;
            return 1;
		}
		else {
			tail->back->value = value;
			tail = tail->back;
			return 1;
		}
		
	}
}

/** Delete an element from the circular queue. Return true if the operation is successful. */
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
  if (NULL == tail) {//判断链表是否为空
		return 0;
	}
	else {
		int temp = head->value;
		if (head == tail) {
			tail = NULL;
			return 1;
		}
		else {
			head = head->back;
            return 1;
		}
		
	}
}

/** Get the front item from the queue. */
int myCircularQueueFront(MyCircularQueue* obj) {
  if (NULL == tail) {
		return -1;
	}
	else {
		
		return head->value;
	}
}

/** Get the last item from the queue. */
int myCircularQueueRear(MyCircularQueue* obj) {
  if (NULL == tail) {
		return -1;
	}
	else {
		return tail->value;
	}
}

/** Checks whether the circular queue is empty or not. */
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
 if (NULL == tail) {
		return 1;
	}
	else{
		return 0;
	}
}

/** Checks whether the circular queue is full or not. */
bool myCircularQueueIsFull(MyCircularQueue* obj) {
  if (head->front == tail) {
		return 1;
	}
	else {
		return 0;
	}
}

void myCircularQueueFree(MyCircularQueue* obj) {//依次对各个节点进行释放
    tail = head->front;
	struct MyCircularQueue *pi1= (struct MyCircularQueue*) malloc(sizeof(MyCircularQueue));
	tail->back = pi1;
	while (pi1 != head->back) {
		tail = head->back;
		free(head);
		head = tail;
	}
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

优点的话内存没有不必要的内存消耗，同时执行速度也非常的迅速。