队列

循环队列的初始化

void Init_Queue(PQUEUE pQ)
{
    int len;
    printf("请输入您要生成队列的长度：");
    scanf("%d", &len);
    len++;//因为会牺牲一个节点作为 Rear的最后一个存储结点，无效节点。所以len必须自加下；
    pQ->pBase = (int *)malloc(sizeof(int)*len);//利用结构体指针创建一个动态数组，队列的核心；
    pQ->Front = pQ->Rear = 0;//初始化时，pQ->Front 与 pQ->Rear 全为 ‘0’；
    return;
}

---

循环队列的遍历

 1). 先判断队列是否为空，如果空，无法遍历
 2). 先定义一个临时变量 T ， int T = pQ->Front; 然后利用 T 作为 动态数组的临时下标值，进行输出
 注意： T 的 移动方式与 Front Rear 移动方式 必须相同。 

bool Traverse_Queue(PQUEUE pQ)
{
    if (Empty_Queue(pQ))
        return false;
    else
    {
        int T = pQ->Front;
        while (T != pQ->Rear)
        {
            printf("%d ", pQ->pBase[T]);
            T = ( T + 1 ) % len;　　
        }
    }
    return true;
}

---

判断循环队列是否为空

bool Empty_Queue(PQUEUE pQ)//当pQ->Front==pQ->Rear 队列此时便为空，因为只有在队列为空时，pQ->Front==pQ->Rear
{
    if (pQ->Front == pQ->Rear)
        return true;
    else
        return false;
}

---

判断循环队列是否已满

bool Full_Queue(PQUEUE pQ)//当队列已满时，Front为第一个队中成员（也就是动态数组的下标值），
                         //Rear为最后一个有效元素的下一个元素。
                        //所以 Rear的再下一个元素如果是Front时，此时队列便已满。
{
    if ((pQ->Rear + 1) % len == pQ->Front)
        return true;
    else
        return false;
}

---

循环队列的出队

bool Out_Queue(PQUEUE pQ, int *pVal)
{
    if (Empty_Queue(pQ))
        return false;
    else
    {
        *pVal = pQ->pBase[pQ->Front];
        pQ->Front = (pQ->Front + 1) % len;
    }
    return true;
}
 1). 先判断队列是否为空，如果已空，则无法进行出队操作
 2). 先在主函数定义一个 int pVal； 然后 地址传递 ，然后指针接收。
 3). 出队具体操作：先把此时 下标值为 pQ->Front 的动态数组的元素 赋给 pVal；
     然后 pQ->Front 在移动，变为下一个元素的下标值。
 总之： pQ->Front 永远指向 动态数组的 第一个元素。

---

循环队列的进队

bool In_Queue(PQUEUE pQ, int val)
{
    if (Full_Queue(pQ))
        return false;
    else
    {
        pQ->pBase[pQ->Rear] = val;
        pQ->Rear = (pQ->Rear + 1) % len;
    }
    return true;
}
1). 先判断队列是否已满，如果满了，便不能再进队。
2). 进队操作：先把值赋给 下标值为 pQ->Rear 的动态数组 的元素，然后 Rear再往下移动。
总之，下标值为 pQ->Rear 的动态数组元素 总是无效的元素。

---

代码如下：

include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <conio.h>

typedef struct Queue
{
    int * pBase;
    int Front;
    int Rear;
}QUEUE, *PQUEUE;

int len;

void Init_Queue(PQUEUE);
bool In_Queue(PQUEUE, int);
bool Out_Queue(PQUEUE, int *);
bool Full_Queue(PQUEUE);
bool Empty_Queue(PQUEUE);
bool Traverse_Queue(PQUEUE);

int main(void)
{
    QUEUE Q;
    Init_Queue(&Q);
    int val, pVal, n;
    while (1)
    {
        system("cls");
        printf("\n\n\n\t\t\n");
        printf("\t\t                  1.进队                   \n");
        printf("\t\t                  2.出队                   \n");
        printf("\t\t                  3.遍历                   \n");
        printf("\t\t                  4.退出                   \n");
        printf("\n\n\n请输入选择项(1-4):");
        scanf("%d", &n);
        switch (n)
        {
        case 1:
            printf("请输入进队元素：");
            scanf("%d", &val);
            if (In_Queue(&Q, val))
                printf("进队成功；\n");
            else
                printf("队列已满，无法进队；\n");
            break;
        case 2:
            if (Out_Queue(&Q, &pVal))
                printf("出队成功，出队的元素是：%d；\n", pVal);
            else
                printf("队列为空，无法出队；\n");
            break;
        case 3:
            if (!Traverse_Queue(&Q))
                printf("队列为空，无法遍历；\n");
            break;
        case 4:exit(-1);
        default:
            printf("您输入有误，请重新输入；\n");
            break;
        }
        printf("请摁任意键继续；\n");
        getch();
    }
    return 0;
}

void Init_Queue(PQUEUE pQ)
{
    printf("请输入您要生成队列的长度：");
    scanf("%d", &len);
    len++;
    pQ->pBase = (int *)malloc(sizeof(int)*len);
    pQ->Front = pQ->Rear = 0;
    return;
}

bool Full_Queue(PQUEUE pQ)
{
    if ((pQ->Rear + 1) % len == pQ->Front)
        return true;
    else
        return false;
}

bool Empty_Queue(PQUEUE pQ)
{
    if (pQ->Front == pQ->Rear)
        return true;
    else
        return false;
}

bool In_Queue(PQUEUE pQ, int val)
{
    if (Full_Queue(pQ))
        return false;
    else
    {
        pQ->pBase[pQ->Rear] = val;
        pQ->Rear = (pQ->Rear + 1) % len;
    }
    return true;
}

bool Out_Queue(PQUEUE pQ, int *pVal)
{
    if (Empty_Queue(pQ))
        return false;
    else
    {
        *pVal = pQ->pBase[pQ->Front];
        pQ->Front = (pQ->Front + 1) % len;
    }
    return true;
}

bool Traverse_Queue(PQUEUE pQ)
{
    if (Empty_Queue(pQ))
        return false;
    else
    {
        printf("遍历队列得：");
        int T = pQ->Front;
        while (T != pQ->Rear)
        {
            printf("%d ", pQ->pBase[T]);
            T = (T + 1) % len;
        }
    }
    printf("\n");
    return true;
}