线性结构的两种常用应用之二 队列

队列

        定义:

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

        分类:

                  链式队列  --用链表实现

                  静态队列  --用数组实现

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

循环队列需要理解的问题:

          1.   静态队列为什么必须是循环队列？

                方便后序的程序运行

          2.   循环队列需要几个参数来确定，                    循环队列各个参数的含义？

 需要2个参数来确定，不同场合有不同的含义

               (1)队列初始化

                front和rear的值都是零

               (2)队列非空

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

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

                (3)队列空

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

       4.   循环队列入队伪算法？

              两步完成:

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

              2.     错误写法:r=r+1

                       正确写法:r=(r+1)%数组的长度

      5.   循环队列出队伪算法？

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

      6.   如何判断循环队列是否为空？

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

       7.    如何判断循环队列是否已满？

             预备知识:

                          front的值可能比rear的值大

                          front的值可能比rear小

                          也可能两者相等

     两种方式:

        1.   多增加一个表标识参数

       2.    少用一个元素(通常使用第二种方式)

                如果f和r的值紧挨着则队列已满。

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

                              已满   

                        else 

                               不满

        队列算法:

                   入队

                   出队

       队列的具体应用:

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

测试

#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);//入队 
bool full_queue(queue*pQ);
void traverse(queue*pQ);
bool emqueue(queue*pQ);
bool put_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);
	traverse(&Q);
	if(put_queue(&Q,&val)){
		printf("出队成功！你需要出队的元素=%d\n",val);
	}
	else
	printf("出队失败！\n");
	traverse(&Q);
	return 0;
} 

初始化

//初始化 
void init(queue*pQ){
	pQ->pbase=(int*)malloc(sizeof(int)*6);//使得pbase指向一个24个字节的数组
	//数组的长度是6 
	pQ->front=0;
	pQ->rear=0;
}

 判断是否为空

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

 判断是否为满

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;
	}
}

     出队   

//出队并保存出队数据 
bool put_queue(queue*pQ,int*pval){
	if(emqueue(pQ)) {
		return false;
	}
	else{
		*pval=pQ->pbase[pQ->front];
		pQ->front=(pQ->front+1)%6;
	}
}

遍历 

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