队列

队列

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

分类：

• 链式队列——用链表实现

• 静态队列——用数组实现

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

循环队列的讲解：

1. 静态队列为什么必须是循环队列——如果不循环，则删除元素前面的空间闲置浪费

2. 循环队列需要几个参数来确定——两个参数来确定rear，front在不同场合有不同含义

   3. 循环队列各个参数的含义——

1）初始化

front和rear的值都是0

2）队列非空

front代表的是队列的第一个元素，在这里删除

rear代表队列最后一个有效元素的下一个元素，在这里添加

3）队列空

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

1. 循环队列入队伪算法讲解

• 将值存入r代表的位置

• rear=(rear+1)%数组的长度以此来循环

1. 循环队列出队伪算法讲解

   • front=(front+1)%数组的长度

2. 是否为空

front==rear则一定为空

1. 是否已满：

front和rear之间大小无规律

 if((rear+1)%数组元素==front)//r和f紧挨着
 {
     已满
 }else{
    不满
 }

front和rear

实战

 #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);
 bool full_queue(QUEUE*);
 void traverse_queue(QUEUE*);
 bool out_queue(QUEUE*,int*);
 bool empty_queue(QUEUE*);
 int main(void)
 {
     QUEUE Q;
     init(&Q);
     int val;
     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);
     en_queue(&Q,8);
     traverse_queue(&Q);
     if(out_queue(&Q,&val))
     {
         printf("出队成功，队列出队元素是：%d\n",val);
     }
     else{
         printf("出队失败！\n");
     }
     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\t",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;
     }
 }

队列的具体应用：

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

队列

 #include<stdio.h>
 void g();
 void k();
 void f();
 void f()
 {
     printf("FFFF\n");
     k();
     printf("1111\n");
 }
 void k()
 {
         printf("kkkk\n");
     g();
     printf("2222\n");
 }
 void g()
 {
         printf("gggg\n");
         printf("3333\n");
 ​
 }
 int main(void){
     f();
     return 0;
 }
 结果为：
 FFFF
 kkkk
 gggg
 3333
 2222
 1111

自己调用自己

 #include<stdio.h>
 ​
 void f(int n)
 {
     if(n==1)
     printf("哈哈\n");
     else
     f(n-1);
 }
 int main(void)
 {
     f(3);
     return 0; 
     
 }
 仅仅输出一个——哈哈