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

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

分类

    链式队列 --  用链表实现

    静态队列 --  用数组实现

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

            循环队列的讲解:

                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("为空!\n");
    }
    if(out_Queue(&pQ,&val)) {
        printf("出队成功!出队的值为%d!\n",val);
    } else {
        printf("为空!\n");
    }
    if(traverse_Queue(&pQ)) {
        printf("为空!\n");
    }
    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("\n");
        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("栈表为空!\n");
        return false;
    } else {
        *val = pQ->pBase[pQ->front];
        pQ->front = (pQ->front+1)%6;
        return true;
    }
}

 

posted @ 2017-07-28 22:42  startor  阅读(508)  评论(0编辑  收藏  举报