线性结构的常见应用之一 队列

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

分类

　　　　链式队列 --  用链表实现

　　　　静态队列 --  用数组实现

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

　　　　　　　　　　　　循环队列的讲解：

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

　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　2.循环队列需要几个参数来确定

　　　　　　　　　　　　　　 　　　　需要两个参数来进行确定：front   rear 

　　　　　　　　　　　　　　　　　　　　　　

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

　　　　　　　　　　　　　　　　　　2个参数在不同的场合有不同的含义  

　　　　　　　　　　　　　　　　　　　　　　建议初学者先记住，后面再想

　　　　　　　　　　　　　　　　　　　　　　　　　　1）、队列初始化

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　front 和 rear 的值都是零

　　　　　　　　　　　　　　　　　　　　　　　　　　2）、队列非空

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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　3）、队列空

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

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

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

　　　　　　　　　　　　　　　　　　　　2.最容易犯得错误的写法：rear = rear + 1；

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

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

　　　　　　　　　　　　　　　　　　　　1.出队和入队是一致的，front=(front+1)%(数组的长度);

　　　　　　　　　　　　　　　　6.如何判断循环队列为什么为空

　　　　　　　　　　　　　　　　　　　　1.如果两个参数的值相等，那么该队列就一定为空

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

　　　　　　　　　　　　　　　　　　　　两种方式：

　　　　　　　　　　　　　　　　　　　　　　1、多增加一个标识位

　　　　　　　　　　　　　　　　　　　　　　2、少用一个元素(也就是判断两者是不是紧挨着)

　　　　　　　　　　　　　　　　　　　　　　　　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);
bool traverse_Queue(QUEUE* pQ);
bool empty_Queue(QUEUE* pQ);
bool out_Queue(QUEUE * pQ,int *val);



int main(void) {
    QUEUE pQ;
    int val;
    init(&pQ);
    en_Queue(&pQ,1);
    en_Queue(&pQ,2);
    en_Queue(&pQ,3);
    en_Queue(&pQ,4);
    en_Queue(&pQ,5);
    en_Queue(&pQ,6);
    en_Queue(&pQ,7);
    en_Queue(&pQ,8);

    if(traverse_Queue(&pQ)) {
        printf("为空!
");
    }
    if(out_Queue(&pQ,&val)) {
        printf("出队成功!出队的值为%d!
",val);
    } else {
        printf("为空!
");
    }
    if(traverse_Queue(&pQ)) {
        printf("为空!
");
    }
    return 0;
}

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

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;
    else
        return false;
}

bool traverse_Queue(QUEUE* pQ) {
    if(empty_Queue(pQ)) {
        return true;
    } else {
        int i = pQ->front;
        while(i != pQ->rear) {
            printf("%d   ",pQ->pBase[i]);
            i = (i+1)%6;
        }
        printf("
");
        return false;
    }
}

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

bool out_Queue(QUEUE * pQ,int *val) {
    if(empty_Queue(pQ)) {
        printf("栈表为空!
");
        return false;
    } else {
        *val = pQ->pBase[pQ->front];
        pQ->front = (pQ->front+1)%6;
        return true;
    }
}