数据结构00——队列（知识点+代码版）

一. 队列的基本概念

1.队列的定义

队列时是允许在一端进行插入，在另一端删除的线性表。 先进先出FIFO

2.队列的基本操作

创销增删查

InitQueue(&Q), DestoryQueue(&Q), EnQueue(&Q,x), DeQueue(&Q,&x), GetHead(Q,&x).

栈和队列是操作受限的线性表。

二. 队列的顺序实现

1.初始化操作

#define MaxSize 10//定义队列中元素的最大个数
typedef struct{
    ElemType data [MaxSize];   //用静态数组存放队列元素 
    int front,rear;          //队头指针和队尾指针 
}SqQueue; //Sq:sequence--顺序 

//初始化队列
void InitQueue(SqQueue &Q){
    //初始时。队头、队尾指针指向0
    Q.rear=Q.front=0;
}

bool QueueEmpty(SqQueue Q){
    if(Q.rear=Q.front)    //队空条件 
        return true;
    else
        return false;
}

2.入队出队查询–循环队列

//入队
bool EnQueue(SqQueue &Q,ElemType x){
    if((Q.rear+1)%MaxSize==Q.front)    //判断队满  
        return false;        //队满报错
    Q.data[Q.rear]=x;        //新元素插入队尾 
    Q.rear=(Q.rear+1)%MaxSize; //队尾指针加1取模 //得到循环队列 
    return true;
}

//出队
bool DeQueue(SqQueue &Q, ElemType &x){
    if(Q.rear=Q.front)
        return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;   //队头指针后移 
    return true;
}

//查询队头元素,用x带回 
bool GetHead(SqQueue Q,ElemType &x){
    if(Q.rear==Q.front)
        return false;
    x=Q.data[Q.front];
    return true;
}

队列元素的个数:(rear+MaxSize-front)%MaxSize

三. 队列的链式实现

//链式队列实现
typedef struct LinkNode{   //链式队列结点 
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct{             //链式队列 
    LinkNode *front,*rear; //队列的队头和队尾指针 
}LinkQueue;

//初始化队列（带头结点）
void InitQueue(LinkQueue &Q){
    ///初始时，front和rear都指向头结点
    Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next==NULL;
}

//判空(带头结点） 
bool isEmpty(LinkQueue Q){
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}

//入队（带头结点）
void EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
}

//出队（带头结点）
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==Q.rear)
        return false;     //空队 
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)        //此次是最后一个结点出队 
        Q.rear=Q.front;
    free(p);
    return true;
}




//初始化（不带头结点）
void InitQueue(LinkQueue &Q){
    ///初始时，front和rear都指向NULL
    Q.front=NULL;
    Q.rear=NULL;
}

//判空（不带头结点）
bool isEmpty(LinkQueue Q){
    if(Q.front==NULL)
        return true;
    else
        return false;
}

//入队（不带头结点）
void EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    if(Q.front==NULL){//空队列插入第一个元素 
        Q.front=s;
        Q.rear=s;
    }
    else{
        Q.rear->next=s;
        Q.rear=s;
    }
}

//出队（不带头结点）
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==NULL)
        return false;
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p){       //此次是最后一个结点出队 
        Q.front=NULL;
        Q.rear=NULL;
    }
    free(p);
    return true;
}

四. 双端队列

考点：判断输出序列的合法性

1.输入输出受限的双端队列（栈）

2.输入受限的双端队列

3.输出受限的双端队列

五. 队列应用

1.树的层次遍历

2.图的广度优先遍历

3.队列在操作系统中的应用

​ 多个进程争抢着使用有限的系统资源时，FCFS(First Come First Service,
先来先服务)是一种常用策略。