1. 队列定义:

  • 一种可以实现 “先进先出” 的存储结构(类似于排队)
  • 只允许在一端插入元素,在另一端删除元素,不可以混在一起

2. 队列分类:

  • 链式队列:由链表实现的队列,本质是链表
  • 静态队列:由数组实现的队列,本质是数组

3.

  1. 静态队列为什么必须时循环队列:静态队列必须是循环队列,这是由数组的特性决定的。队列只允许尾部添加元素头部删除元素,如果用数组实现,添加元素时元素向后排列,删除元素时前面的位置就会空出来,时间长了之后会造成大量的空间浪费,所以要使用循环队列,以防止空间浪费
    循环队列的实现及细节-LMLPHP
    非循环队列,会浪费很多空间
    循环队列的实现及细节-LMLPHP
    循环队列,不会浪费空间
  2. 循环队列需要几个参数来确定:两个,即队列头、尾(实质上就是数组的两个下标)
  3. 循环队列各个参数的含义:
    • 循环队列需要两个参数来确定,且这两个参数在不同的情况下由不同的含义
    • 队列初始化时:front和rear值都为零
  4. 如何判断循环队列是否为空:若 rear == front 则队列为空
  5. 如何判断循环队列是否为满:若 (rear + 1)% 数组长度 == front 则队列已满(因为 rear 指示的是队列最后一个有效元素的下一个元素,所以这样判断队列已满会浪费一个数组位置,但是这已经比非循环队列省了很多空间了。如果要不浪费哪一个元素就需要多加一个参数,这样就会麻烦很多,没有必要)

4. 循环队列实现及细节

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

typedef struct Queue{
    int *pBase;                               //指向数组的指针
    int front;                                //队列头,数值尾队列第一个有效元素的下标
    int rear;                                 //队列尾,数值尾队列最后一个有效元素的下一个元素的下标
}QUEUE,*PQUEUE;

PQUEUE InitQueue(void);
/**操作结果:构造一个空队列Q */
void DestoryQueue(PQUEUE pQ);
/**初始条件:队列已经存在
 * 操作结果:队列被销毁
 */
void ClearQueue(PQUEUE pQ);
/**初始条件:队列已经存在
 * 操作结果:将队列清空
 */
bool QueueEmpty(PQUEUE pQ);
/**初始条件:队列已经存在
 * 操作结果:若队列为空,返回TURE,否则返回FALSE
 */
bool QueueFull(PQUEUE pQ);
/**初始条件:队列已存在
 * 操作结果:若队列已满,返回TURE,否则返回FALSE
 */
int QueueHead(PQUEUE pQ,int val);
/**初始条件:队列存在且非空
 * 操作结果:返回队列头元素
 */
bool EnQueue(PQUEUE pQ,int val);
/**初始条件:队列已存在
 * 操作结果:在队尾插入元素
 */
bool DeQueue(PQUEUE pQ,int *pVal);
/**初始条件:队列存在且非空
 * 操作结果:删除队头元素,并返回其值
 */
void QueueTraverse(PQUEUE pQ);
/**初始条件:队列存在且非空
 * 操作结果:输出队列元素
 */

int N;                                       //N 用于在各个函数之间传递队列的实际长度

int main()
{
    int t;
    printf("请输入队列长度:");               //这里用 N + 1 是因为输入的队列长度是实际元素的个数,因为循环队列会浪费一个元素,所以令队列的实际长度为 N + 1 方便使用
    scanf("%d",&t);
    N=t+1;
    PQUEUE pQ=InitQueue();
    int i,n;
    for(i=0;i<N-1;i++){                      //用户输入的队列长度为 N - 1
        scanf("%d",&n);
        EnQueue(pQ,n);
    }
    QueueTraverse(pQ);
    int val;
    DeQueue(pQ,&val);
    QueueTraverse(pQ);
    printf("出队元素为:%d",val);
}

PQUEUE InitQueue(void)                       //构造一个空队列
{
    PQUEUE pQ=(PQUEUE)malloc(sizeof(QUEUE)); //这里必须用 malloc 函数,否则生成的就是一个局部变量。在这里错了好几次,应当注意!!
    pQ->pBase=(int *)malloc(sizeof(int)*N);
    pQ->rear=0;                              //因为这是一个空队列,其中没有任何有效元素,所以 rear 和 front 的值都为零
    pQ->front=0;
    return pQ;
}

void DestoryQueue(PQUEUE pQ)                 //销毁队列
{
    free(pQ);
}

void ClearQueue(PQUEUE pQ)                   //清空队列
{
    pQ->front=pQ->rear;                      //清空队列时并不需要将队列里所有元素都重置为零,只需要令 front 与 rear 的值相同即可,以后入队时输入的值就会把原来的值覆盖
}

bool QueueEmpty(PQUEUE pQ)                   //判断队列是否为空
{
    if(pQ->front==pQ->rear){
        return true;
    }else{
        return false;
    }
}

bool QueueFull(PQUEUE pQ)                    //判断队列是否已满
{
    int m,n;
    m=pQ->rear;
    n=pQ->front;
    if((m+1)%N==(n)) {
        return true;
    }else{
        return false;
    }
}

int QueueHead(PQUEUE pQ,int val)              //返回队列头元素
{
    val=pQ->pBase[pQ->front];
    return val;
}

bool EnQueue(PQUEUE pQ,int val)               //在队尾插入元素
{
    if(QueueFull(pQ)){
        return false;
    }else{
        pQ->pBase[pQ->rear]=val;
        pQ->rear=(pQ->rear+1)%N;
        return true;
    }
}

bool DeQueue(PQUEUE pQ,int *pVal)             //删除队头元素并返回其值
{
    if(QueueEmpty(pQ)){
        return false;
    } else{
        *pVal=pQ->pBase[pQ->front];           //这里因为需要函数类型为 bool ,所以无法正常返回 int 类型的值,所以用指针直接修改 val 的值即可
        pQ->front=(pQ->front+1)%N;
        return true;
    }
}

void QueueTraverse(PQUEUE pQ)                 //遍历输出队列元素
{
    int i=pQ->front;
    while(i!=pQ->rear){
        printf("%d ",pQ->pBase[i]);
        i=(i+1)%N;
    }
    printf("\n");
}
07-19 01:27