循环队列详细讲解

定义：一种可以实现“先进先出”的存储结构

分类：

链式队列---用链表实现

静态队列---用数组实现

静态队列通常都必须是循环队列

循环队列讲解：

1. 静态队列为什么必须是循环队列：当出队的时候，front上移，因为静态队列使用数组表示，则出队的后那个空间不能够利用，造成内存空间浪费。
2. 循环队列需要几个参数来确定及其含义的讲解：需要2个参数来确定，front,rear

2个参数在不同的场合有不同的含义:

1. 队列初始化：front和rear的值都是零
2. 队列非空：front代表的是队列的第一个元素；rear代表的是队列的最后一个有效元素的下一个元素
3. 队列空：front和rear的值相等，但不一定是零                                                                            

入队伪算法讲解：

两步完成：

（1）将值存入rear所代表的位置

（2）错误写法：rear = rear+1;

     正确写法：rear = (rear+1)%数组的长度

循环队列出队伪算法讲解

1. 若想保持出队数据：（1）先保存出队数据（2）front  = (front +1)%数组长度
2. 不想保存出队数据：front = (front+1)%数组长度

如何判断循环队列是否为空：

如果front和rear的值相等，则该队列就一定为空

如何判断循环队列是否已满：

预备知识：

front和值可能比rear大，也可能比rear小，也可能相等

两种方式：

1. 多增加一个标识参数
2. 少用一个元素【通常使用这个方式】

用算法表示循环队列是否满：

if( (rear+1)%数组长度 == front)

已满

else

不满

队列算法：

出队，入队

队列的具体应用：

所有和时间有关的操作都有队列的影子

创造一个空的循环队列：

void init(QUEUE *pQ)
{
	pQ->pBase = (int *)malloc(sizeof(int) * 6);
	pQ->front = 0;
	pQ->rear = 0;
}

入队：

bool en_queue(QUEUE *pQ, int val)
{
	if(is_full(pQ))
		return false;
	else
	{
	   pQ->pBase[pQ->rear] = val;
	   pQ->rear = (pQ->rear + 1)%6;
	   return true;
	}
}

判断队列是否满了：

bool is_full(QUEUE *pQ)
{
	if((pQ->rear + 1)%6 == pQ->front)
		return true;
	else
		return false;
}

判断队列是否为空：

bool is_empty(QUEUE *pQ)
{
	if(pQ->front == pQ->rear)
		return true;
	else
		return false;
}

遍历输出：

void traverse_queue(QUEUE *pQ)
{
	int i = pQ->front;
	while(i != pQ->rear)
	{
		printf("%d\n",pQ->pBase[i]);
		i = (i+1)%6;
	}
	return;
}

出队：

bool out_queue(QUEUE *pQ, int *pVal)
{
  if(is_empty(pQ))
	  return false;
  else
  {
	  *pVal  = pQ->pBase[pQ->front];
	  pQ->front = (pQ->front + 1)%6;
	  return true;
  }
}

结果：

 完整代码：

#include <stdio.h>
#include<malloc.h>
typedef struct Queue
{
  int *pBase;
  int front;
  int rear;
}QUEUE;
void init(QUEUE *pQ);
bool en_queue(QUEUE *pQ, int val);
void traverse_queue(QUEUE *pQ);
bool is_full(QUEUE *pQ);
bool is_empty(QUEUE *pQ);
bool out_queue(QUEUE *pQ, int *pVal);
int main(void)
{
  QUEUE Q;
  int val;
  init(&Q);
  
  en_queue(&Q,1);
  en_queue(&Q,2);
  en_queue(&Q,3);
  en_queue(&Q,4);
  en_queue(&Q,5);
  en_queue(&Q,6);
  en_queue(&Q,7);
  traverse_queue(&Q);
  
 
  if(out_queue(&Q,&val))
  {
    printf("出队成功！\n");
	printf("出队元素是：%d\n",val);
  }
  else
	  printf("出队失败！\n");
  traverse_queue(&Q);
  return 0;
}
void init(QUEUE *pQ)
{
	pQ->pBase = (int *)malloc(sizeof(int) * 6);
	pQ->front = 0;
	pQ->rear = 0;
}
bool en_queue(QUEUE *pQ, int val)
{
	if(is_full(pQ))
		return false;
	else
	{
	   pQ->pBase[pQ->rear] = val;
	   pQ->rear = (pQ->rear + 1)%6;
	   return true;
	}
}
bool is_full(QUEUE *pQ)
{
	if((pQ->rear + 1)%6 == pQ->front)
		return true;
	else
		return false;
}
void traverse_queue(QUEUE *pQ)
{
	int i = pQ->front;
	while(i != pQ->rear)
	{
		printf("%d\n",pQ->pBase[i]);
		i = (i+1)%6;
	}
	return;
}
bool is_empty(QUEUE *pQ)
{
	if(pQ->front == pQ->rear)
		return true;
	else
		return false;
}
bool out_queue(QUEUE *pQ, int *pVal)
{
  if(is_empty(pQ))
	  return false;
  else
  {
	  *pVal  = pQ->pBase[pQ->front];
	  pQ->front = (pQ->front + 1)%6;
	  return true;
  }
}