数据结构：循环队列

        为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列

 

   （图来自网络）

本篇   rear表示队尾位置的下一个位置；
          front表示当前队头的元素位置；

循环队列函数实现：

1.初始化

2.判满

3.入队

4.判空

5.出队

6.清队

 

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

typedef int ELEM_TYPE;
#define MAXSIZE 10

typedef struct Queue
{
	ELEM_TYPE data[MAXSIZE];
	int rear; //队尾位置的下一个位置；
	int front;//当前队头的元素位置；
}Queue,*PQueue;

void Init(PQueue pqu)
{
	if (pqu == NULL)
	{
		return;
	}
	pqu->phead = pqu->prear = NULL;
}

bool Push(PQueue pqu, ELEM_TYPE val)
{
	if (pqu == NULL)
	{
		return false;
	}
	Node* pnewnode = (Node*)malloc(sizeof(Node));
	pnewnode->mdata = val;
	pnewnode->pnext = NULL;

	if (pqu->phead == NULL)
	{
		pqu->phead = pqu->prear = pnewnode;
	}
	else
	{
		pqu->prear->pnext = pnewnode;
		pqu->prear = pnewnode;
	}
	return true;
}
bool IsEmpty(PQueue pqu)
{
	return (pqu->phead == pqu->prear) && (pqu->phead == NULL) ;
}
bool Pop(PQueue pqu, ELEM_TYPE* prt)
{
	if (pqu == NULL)
	{
		return false;
	}
	if (IsEmpty(pqu))
	{
		return false;
	}
	Node* pCur = pqu->phead;
	*prt = pCur->mdata;
	if (pCur->pnext == NULL)
	{
		pqu->phead = pqu->prear = NULL;
	}
	else
	{
		pqu->phead = pCur->pnext;
	}
	free(pCur);
	return true;
}

void Print(PQueue pqu)
{
	if (pqu == NULL)
	{
		return;
	}
	Node* pCur = pqu->phead;
	while (pCur != NULL)
	{
		printf("%d ", pCur->mdata);
		pCur = pCur->pnext;
	}
	printf("\n");
}
bool back(PQueue pqu, ELEM_TYPE* prt)
{
	if (pqu == NULL)
	{
		return false;
	}
	if (IsEmpty(pqu))
	{
		return false;
	}
	*prt = pqu->prear->mdata;
	return true;
}
bool front(PQueue pqu, ELEM_TYPE* prt)
{
	if (pqu == NULL)
	{
		return false;
	}
	if (IsEmpty(pqu))
	{
		return false;
	}
	*prt = pqu->phead->mdata;
	return true;
}

void Clear(PQueue pqu)
{
	if (pqu == NULL)
	{
		return;
	}
	Node* pCur = pqu->phead;
	Node* pNext = pCur;
	pqu->phead = pqu->prear = NULL;
	while (pCur != NULL)
	{
		pNext = pCur->pnext;
		free(pCur);
		pCur = pNext;
	}
}
void Destroy(PQueue pqu)
{
	Clear(pqu);
}