队列

什么是队列？

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

出队  入队  -->>队列

出栈  压栈  -->>栈

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

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

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

039.循环队列需要几个参数来确定极其含义的讲解

front代表的是队列的第一个元素

rear代表的是队列的最后一个有效元素的下一个元素

队列为空：

front和rear的值相等，但不一定为零

队列初始化

front和rear的值都是零.

循环队列入队的伪算法

1）将入队的值存入r所代表的位置

2）r=(r+1)%数组的长度

循环队列出队的伪算法

1）将出队的值存入f所代表的位置

2）f=(f+1)%数组的长度

判断队列是否已满

if（（r+1）%数组的长度 == f）

已满

else

不满

队列的具体操作

#include <stdio.h>
#include <malloc.h>

/**
 *
 *队列的创建...等操作
 *
 */
typedef struct Queue
{
	int * pBase;
	int front;
	int rear;
}QUEUE;

void init(QUEUE *);
bool en_queue(QUEUE *, int val);
void traverse_queue(QUEUE *);
bool full_queue(QUEUE *);
bool empty_queue(QUEUE *);
bool out_queue(QUEUE *, int *);

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("出队成功，出队的元素是 %d \n", val);
	}
	else
	{
		printf("出队失败");
	}
	traverse_queue(&q);

	return 0;
}

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

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

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

		return true;
	}
}

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

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

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

（郝斌讲学）数据结构学习篇（五）---队列的CRUD操作