从小白开始自学数据结构——第六天【队列】

线性结构的应用–队列
定义：
一种可以实现“先进先出”的存储结构
分类：
链式队列——用链表实现
比静态队列简单。。。真的，循环太打脑壳了

             静态队列——用数组实现
                 静态队列通常都必须是循环队列

                 循环队列：
                     1.静态队列为什么必须是循环队列
                           无论入队还是出队，只能加不能减。

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

                     3.循环队列各个参数的含义                              
                           两个参数在不同场合有不同的含义
                               1.队列初始化
                                     font和rear都是0
                               2.队列非空
                                     font代表的是队列的第一个元素
                                     rear代表的是队列最后一个有效元素的下一个
                               3.队列空
                                     front和rear相等，但不一定是0.
                                        空的时候指向同一点但不一定是0

                     4.循环队列入队伪算法
                           1.将值存入r所代表的位置
                           2.将r后移
                                 错误写法：r = r +1
                                 正确写法是：r = （r+1）% 数组长度

                     5.循环队列出队伪算法
                           1.保存出队的值
                           2.f = （f+1）% 数组长度

                     6.如何判断循环队列是否为空
                           front和rear相等（但不一定是0），则为空

                     7.如何判断循环队列是否已满
                           1.多增加一个参数 
                           2.少用一个元素【通常用这个】
                               如果r和f的值相邻，则队列已满
                                   if（r+1）%数组长度 == front
                                      数组已满

/**************************
      队列的基本算法
**************************/
# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>

void inint (struct Queue *, int len);             //新建一个队列
bool is_empty (struct Queue *);                   //队列的空判断
bool is_full (struct Queue *);                    //队列的满判断
bool en_queue (struct Queue *, int);              //入队
bool out_queuqe (struct Queue *, int *);          //出队
void traverse_queue (struct Queue *);             //遍历输出

struct Queue
{
    int * pBase;
    int front;
    int rear;
};

int main ()
{
    struct Queue Que;
    inint (&Que, 6);
    en_queue (&Que, 1);
    en_queue (&Que, 2);
    en_queue (&Que, 3);
    en_queue (&Que, 4);
    en_queue (&Que, 5);
    en_queue (&Que, 6);
    //虽然是六个的位置但是只能放五个，因为有个位置拿来给rear判断是否队满了
    traverse_queue (&Que);

    int val;
    if ( out_queuqe (&Que, &val) == true)
    {
        printf ("出队成功，出队元素是%d\n", val);
    }
    if ( out_queuqe (&Que, &val) == true)
    {
        printf ("出队成功，出队元素是%d\n", val);
    }

    traverse_queue (&Que);


    return 0;
}

void inint (struct Queue * pQue, int len)
{
    pQue->pBase  = (int*)malloc(sizeof(int) * len);
    pQue->front = 0;
    pQue->rear = 0; 
}

bool is_full (struct Queue * pQue)
{
    if ((pQue->rear + 1)%6 == pQue->front )
    {
        return false;
    }
    else
        return true;
}

bool is_empty (struct Queue * pQue)
{
    if ((pQue->rear )== (pQue->front))
        return false;
    else
        return true;
}

bool en_queue (struct Queue * pQue, int val)
{
    if ( is_full(pQue) == false)
    {
        printf ("队列已满。\n");
        return false;
    }
    else
    {
        pQue->pBase [pQue->rear] = val;
        pQue->rear = (pQue->rear+1) % 6;
    }

    return true;
}

bool out_queuqe (struct Queue * pQue, int * val)
{
    if ( is_empty(pQue) == false)
    {
        printf ("队列为空。\n");
        return false;
    } 
    else
    {
        *val = pQue->pBase [pQue->front];
        pQue->front  = (pQue->front+1) % 6;  
    }

    return true;
}


void traverse_queue (struct Queue * pQue)
{
    int j = 1;
    int i = pQue->front ;//i很有必要，因为遍历不能改变函数
    while (i!=pQue->rear)
    {
        printf ("队列中排第%d的元素是%d\n", j, pQue->pBase [i]);
        j++;
        i=(i+1)%6;
    }
    return;
}