队列_静态循环队列

1、 队列

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

                  分类        

                                    链式队列         用链表实现

                                    静态队列         用数组实现（为了节约存储空间通常采用循环队列）

                  应用  

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

2、循环队列

              循环队列两个参数   front      rear

                                                  front      代表循环队列的第一个元素

                                                  rear       代表循环队列的最后一个元素的下一个元素

                                                                                  （注意:）front 可能比rear大也可能比rear小

                                                 初始状态 即队列为空时front与rear相等但不一定为零

3、循环队列相关操作

              -1、入队

                                     将值放入rear 所代表的位置

                                    rear =（ rear+1）%队列的长度

              -2、 出队列

                                front =（ front+1）%队列的长度

              -3、 队列为空

                                 front = rear

               -4、循环队列为满

                                           通常采用两种方案实现

                                                         在队列中增加一个参数 如：增加len来代表队列的实际长度    该方案的缺点是每次对队列进行完相关操作后都要更新len的值

                                                         少用一个存储空间 即 队列长度为n最多存放n-1个数据（常用）

                                                                       如果rear 和front相邻表明队列已满

                                                                                                                   即if（rear =（ rear+1）%队列的长度=front）

                                                                                                                  队列满

                                                                                              else

                                                                                                               队列不满

4、队列的相关操作实现

                   动态队列的实现 即对链表的受限操作“先进先出”较容易 参见链表的相关操作

                   静态队列的实现 即一般用数组实现的循环队列具体实现如下：

 

/*利用数组实现静态循环队列*/
# include<stdio.h>
# include<malloc.h>
typedef struct Queue
{
	int * pBase;
	int front;
	int rear;
}QUEUE;

void init_queue( QUEUE * pQ );			//初始化队列
bool in_queue( QUEUE * pQ,int val );	//入队列
void traverse_queue( QUEUE * pQ );		        //出队列
bool full_queue( QUEUE *pQ );			//判断队列是否为满
bool out_queue( QUEUE *pQ, int *pVal );	        //出队列
bool empty_queue( QUEUE *pQ );			//判断队列是否为空

int main(void)
{
	int val;	
	QUEUE Q;					         //定义一个队列
	init_queue( &Q );					//入队
	in_queue(&Q,3);
	in_queue(&Q,5);
	in_queue(&Q,7);
	in_queue(&Q,9);
	in_queue(&Q,55);
	traverse_queue( &Q );				//输出队列
	if (out_queue( &Q, &val))
	{
		printf("出队列成功，出队列元素为%d\n",val);
	}
	traverse_queue( &Q );
	return 0;
}
void init_queue(QUEUE * pQ)
{
	pQ->pBase = (int *) malloc (sizeof(QUEUE) * 5);
	pQ->front = 0;
	pQ->rear = 0;
}
bool in_queue(QUEUE * pQ,int val)
{
	if(full_queue(pQ))
	{
		printf("入队失败\n");
		return false;
	}
	else
	{
		pQ->pBase[pQ->rear] = val;
		pQ->rear = ( pQ->rear +1 ) % 5;		
		return true;
	}
}
bool full_queue( QUEUE *pQ )
{
	if((pQ->rear + 1) % 5 == pQ->front)
		return true;
	else 
		return false;
}
void traverse_queue( QUEUE * pQ )
{
	int i = pQ->front;
	while ( i != pQ->rear)
	{
		printf("%d ", pQ->pBase[i]);
		i = ( i + 1 ) % 5;
	}
	printf("\n");
}
bool out_queue( QUEUE *pQ, int *pVal )
{
	if(empty_queue(pQ))
	{
		printf("队列为空出队列失败\n");
		return false;
	}
	else
		*pVal = pQ->pBase[pQ->front];
		pQ->front = ( pQ->front + 1) % 5;
		return true;
}
bool empty_queue( QUEUE *pQ )
{
	if (pQ->front == pQ->rear)
		return true;
	else
		return false;
}

运行结果如下：

入队失败
3 5 7 9
出队列成功，出队列元素为3
5 7 9
请按任意键继续. . .