数据结构---队列（c语言）

队列

队列定义

• 一种可是实现“先进先出”的存储结构

分类

• 链式队列：用链表实现
• 静态队列：用数组实现
  静态队列通常都必须是循环队列，为了减少内存浪费

循环队列的讲解

1. 静态队列为什么是循环队列
   
2. 循环队列需要几个参数来确定
   两个参数：两个参数不同场合有不同的含义，类似如下：
   （1）front：指向第一个元素
   （2） rear：指向最后一个元素的下一个元素
3. 循环队列各个参数的含义
   2个参数不同场合不同的含义：场合如下：
   （1）队列初始化：
   font 和 rear 的值都是零
   （2）队列非空
   font 代表队列的第一个元素，rear 代表的是队列的最后一个元素的下一个元素
   （3）队列空
   font 和 rear 的值相等，但不一定是零
4. 循环队列入队伪算法的讲解
   
5. 循环队列出队伪算法的讲解
   
6. 如何判断循环队列是否为空
   如果front与rear的值相等，则队列一定为空
7. 如何判断循环队列是否已满
   front 和 rear 的值没有规律，即可以大，小，相等
   两种方式：
   （1）多增加一个表标识的参数
   （2）少用一个队列中的元素（才一个，不影响的）
   - ----通常使用第二种方法
   如果r和f的值紧挨着，则队列已满即：
   用C语言伪算法表示就是：
   if( (r+1)%数组长度 == f )
   已满
   else
   不满
   

循环队列算法的实现（c语言）

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

typedef enum _bool {
    
    false = 0,true = 1} bool;

typedef struct queue
{
    
    
    int * pBase;
    int front;
    int rear;
}QUEUE;

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

//初始化队列
void init(QUEUE *pQ)
{
    
    
    pQ->pBase = (int *)malloc(sizeof(int)*6);
    pQ->front = 0;
    pQ->rear = 0;

    return ;
}

//插入
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 full_queue(QUEUE * pQ)
{
    
    
    if((pQ->rear + 1) % 6 == pQ->front)
    {
    
    
        return true;
    }

    return false;
}


//遍历队列
void traverser_queue(QUEUE *pQ)
{
    
    
    int i = pQ->front;
    while(i != pQ->rear)
    {
    
    
        printf("data in queue is %d\n",pQ->pBase[i]);
        i = (i + 1) % 6;
    }

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

int main()
{
    
    
    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);
    en_queue(&q,8);

    if(full_queue(&q))
    {
    
    
        printf("队列已满!其中元素为\n");
        traverser_queue(&q);
    }
    else
    {
    
    
        printf("队列未满\n");
        traverser_queue(&q);
    }

    //出队测试
    if(out_queue(&q,&val))
    {
    
    
        printf("出队成功，出队的值为 %d\n",val);
        traverser_queue(&q);
    }
    else
    {
    
    
         printf("出队失败！\n");
    }
    return 0;
}

队列的具体应用

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